


<img src="/assets/img/2024-08-26-HowValueAnimatorBringsAndroidsUItoLife_0.png" />

안녕하세요, 여러분! 오늘은 안드로이드의 ValueAnimator를 살펴보겠습니다. 부드럽고 활기찬 애니메이션을 만드는 데 필수적인 도구입니다. 또한 이를 더 잘 이해하기 위해 간단한 사용자 정의 버전을 만들어 볼 것입니다. 또한 메인 루퍼가 UI 이벤트 및 렌더링을 처리하는 방법을 살펴볼 것입니다. 자, 시작해봅시다. 우리의 UI를 춤추게 하는 방법을 알아봅시다!

# ValueAnimator란 무엇인가요?

먼저, 안드로이드에서 ValueAnimator를 어떻게 정의하는지 살펴봅시다:


<div class="content-ad"></div>

더 간단히 말하면, ValueAnimator는 지정된 기간 동안 시작점에서 끝점까지 값을 전환합니다. 0에서 1까지 변하는 소수 값인 비율(fraction)을 사용하여 애니메이션 진행 상황을 나타냅니다. 이 비율은 애니메이션이 시작할 때 0에서 시작하여 끝날 때 1에 도달합니다. ValueAnimator는 시간이 흐름에 따라 비율을 업데이트함으로써 중간 값을 계산하고 부드러운 전환을 생성합니다.

![HowValueAnimatorBringsAndroidsUItoLife](/assets/img/2024-08-26-HowValueAnimatorBringsAndroidsUItoLife_1.png)

# 예제: 뷰를 수평으로 이동하기

다음은 ValueAnimator의 하위 클래스인 ObjectAnimator를 사용하여 뷰를 오른쪽으로 100픽셀 이동하는 기본적인 예제입니다:

<div class="content-ad"></div>

```js
ObjectAnimator.ofFloat(view, "translationX", 0f, 100f).apply {
    duration = 1000L
    start()
}
```

또는 ValueAnimator를 직접 사용할 수도 있습니다:

```js
ValueAnimator.ofFloat(0f, 100f).apply {
    duration = 1000L
    addUpdateListener {
        view.translationX = animatedValue as Float
    }
    start()
}
```

# 뷰를 양방향으로 이동하기

<div class="content-ad"></div>

뷰를 한 번에 오른쪽으로 200픽셀, 아래로 350픽셀 이동하고 싶다면 두 개의 독립적인 ValueAnimator를 사용하여 이를 달성할 수 있습니다:

```js
ValueAnimator.ofFloat(0f, 200f).apply {
    duration = 1000L
    addUpdateListener {
        view.translationX = animatedValue as Float
    }
    start()
}

ValueAnimator.ofFloat(0f, 350f).apply {
    duration = 1000L
    addUpdateListener {
        view.translationY = animatedValue as Float
    }
    start()
}
```

또는, 하나의 ValueAnimator만 사용하여 더 효율적으로 만들 수도 있습니다. animatedFraction을 이용하면 ValueAnimator의 내부 계산을 건너뛰고 개별적인 계산을 할 수 있습니다:

```js
ValueAnimator.ofFloat(0f).apply {
    duration = 1000L
    addUpdateListener {
        view.translationX = 200f * animatedFraction
        view.translationY = 350f * animatedFraction
    }
    start()
}
```

<div class="content-ad"></div>

이 예제에서는 animatedFraction을 사용하여 뷰의 위치를 수동으로 계산합니다. 이 방법을 사용하면 분수를 애니메이션화하고 뷰의 속성에 대한 사용자 정의 계산을 적용하여 로직을 간단하게 만들 수 있습니다. 따라서 0에서 1로 분수를 애니메이션화하고 나머지는 우리만의 사용자 정의 논리로 처리할 수 있습니다.

## ValueAnimator는 언제 업데이트해야 하는지 어떻게 알까요?

각 디스플레이 새로 고침마다 ValueAnimator는 세 가지 주요 매개변수를 사용하여 분수를 다시 계산합니다: 애니메이션 시작 시간, 프레임 렌더 전 현재 시간 및 총 기간.

그렇다면 ValueAnimator가 새로운 프레임이 렌더링될 때 알고, 언제 업데이트 콜백을 호출해야 할까요?
이 마법은 Choreographer의 도움으로 이루어집니다. ValueAnimator는 디스플레이 새로 고침 비율에 애니메이션을 동기화하기 위해 Choreographer를 사용합니다.

<div class="content-ad"></div>

ValueAnimator가 시작되면 Choreographer에 프레임 콜백을 등록합니다. Choreographer는 화면이 다음 프레임을 그릴 준비가 되었을 때를 나타내는 VSYNC 신호를 수신합니다. VSYNC 신호를 받으면 Choreographer는 ValueAnimator의 doAnimationFrame() 메서드를 호출하여 분수를 업데이트하고 새로운 애니메이션 값으로 업데이트 리스너를 호출합니다.

![Image](/assets/img/2024-08-26-HowValueAnimatorBringsAndroidsUItoLife_2.png)

- ValueAnimator는 Choreographer와 프레임 콜백을 등록합니다.
- Choreographer는 VSYNC 신호를 기다려서 화면 업데이트가 디스플레이의 주사율과 동기화되도록 합니다.
- VSYNC에서 Choreographer가 ValueAnimator의 doAnimationFrame()을 호출합니다. ValueAnimator는 분수를 업데이트하고 새로운 애니메이션 값이 계산됩니다.

# 간단한 사용자 정의 애니메이터 생성

<div class="content-ad"></div>

안녕하세요! 안드로이드 Choreographer API를 사용하여 ValueAnimator의 간단한 버전을 만들어 봅시다. 여기에 샘플 구현이 있어요:

```js
fun startMySimpleAnimator(
    duration: Long = 300,
    startDelay: Long = 0,
    interpolator: TimeInterpolator = AccelerateDecelerateInterpolator(),
    onUpdate: (Float) -> Unit,
) {
    val durationNanos = duration * 1_000_000
    val startTimeNanos = System.nanoTime()

    val frameCallback = object : FrameCallback {
        override fun doFrame(frameTimeNanos: Long) {
            val elapsedNanos = frameTimeNanos - startTimeNanos
            val fraction = (elapsedNanos.toFloat() / durationNanos).coerceIn(0f, 1f)
            val interpolatedFraction = interpolator.getInterpolation(fraction)
            onUpdate(interpolatedFraction)

            if (fraction < 1f) {
                Choreographer.getInstance().postFrameCallback(this)
            }
        }
    }
    Choreographer.getInstance().postFrameCallbackDelayed(frameCallback, startDelay)
}
```

```js
startMySimpleAnimator(duration = 1000L) { animatedFraction ->
    view.translationX = 200f * animatedFraction
    view.translationY = 350f * animatedFraction
}
```

이 간단한 코드를 사용하여 animatedFraction에 의존하는 ValueAnimator와 유사한 기본 애니메이터를 만들었습니다. 이 예제를 확장하여 ValueAnimator가 제공하는 더 많은 기능을 지원하도록 쉽게할 수 있습니다. 그리고 화면의 새로 고침 속도와 매끄럽게 동기화되는 애니메이션을 유지할 수 있어요. 이렇게 간단하죠!

<div class="content-ad"></div>

# 하나의 타이밍 펄스로 애니메이션 동기화

안드로이드는 또한 다음과 같이 설명합니다:

우리는 기본 예제를 약간 수정하여 사용자 정의 애니메이터 구현에서 이와 같은 동작을 달성할 수 있습니다. 각 MySimpleAnimator가 자체 프레임 콜백을 처리하는 대신, 모든 애니메이션이 동기화되도록 이를 단일 타이밍 펄스로 집중할 수 있습니다. 아래에 설명된 방법을 따르세요:

```js
class MySimpleAnimator(
    private val onUpdate: (Float) -> Unit,
) : Animator(), FrameCallback {

    private var startTimeNanos: Long = 0L
    private var durationNanos: Long = 300L
    private var startDelayNanos: Long = 0L
    private var timeInterpolator: TimeInterpolator? = AccelerateDecelerateInterpolator()
    private var mIsRunning: Boolean = false

    override fun doFrame(frameTimeNanos: Long) {
        val elapsedNanos = frameTimeNanos - startTimeNanos - startDelayNanos
        if (elapsedNanos <= 0) {
            return
        }
        val fraction = (elapsedNanos.toFloat() / durationNanos).coerceIn(0f, 1f)
        val interpolatedFraction = timeInterpolator?.getInterpolation(fraction)
        onUpdate(interpolatedFraction ?: fraction)
        mIsRunning = fraction < 1f
    }

    override fun start() {
        startTimeNanos = System.nanoTime()
        mIsRunning = true
        MySimpleAnimatorHandler.attach(this)
    }

    override fun setStartDelay(startDelay: Long) {
        startDelayNanos = startDelay * NANO_MS
    }

    override fun setDuration(duration: Long): MySimpleAnimator {
        durationNanos = duration * NANO_MS
        return this
    }

    override fun setInterpolator(value: TimeInterpolator?) {
        timeInterpolator = value
    }

    override fun getStartDelay(): Long = startDelayNanos / NANO_MS
    override fun getDuration(): Long = durationNanos / NANO_MS
    override fun getInterpolator(): TimeInterpolator? = timeInterpolator
    override fun isRunning(): Boolean = mIsRunning
}

private const val NANO_MS = 1_000_000
```

<div class="content-ad"></div>

```kotlin
private object MySimpleAnimatorHandler : FrameCallback {
    private val animations = mutableListOf<MySimpleAnimator>()

    fun attach(animator: MySimpleAnimator) {
        if (animations.isEmpty()) {
            Choreographer.getInstance().postFrameCallback(this)
        }
        animations.add(animator)
    }

    override fun doFrame(frameTimeNanos: Long) {
        animations.removeIf { animator ->
            animator.doFrame(frameTimeNanos)
            animator.isRunning.not()
        }
        if (animations.isNotEmpty()) {
            Choreographer.getInstance().postFrameCallback(this)
        }
    }
}
```

이 설정은 하나의 FrameCallback을 사용하여 여러 애니메이션을 관리합니다. 이는 ValueAnimator가 모든 애니메이션에 대해 하나의 타이밍 펄스를 사용하는 방식과 유사합니다.

# Choreographer의 작동 방식은?

이제 ValueAnimator를 살펴보았으니, Choreographer를 사용하여 새로운 프레임을 렌더링할 시점을 안드로이드가 어떻게 결정하는지 살펴보겠습니다.


<div class="content-ad"></div>

안드로이드에 따르면, Choreographer는 Android의 UI 랜더링 시스템 중심 부분으로 애니메이션, 입력 이벤트 및 그리기의 타이밍을 관리합니다.

Choreographer를 시스템 수준의 타이밍 신호와 응용 프로그램 수준 콜백을 연결하는 다리로 생각해보세요. UI 렌더링 및 애니메이션을 다루고 있기 때문에 일반적으로 Main Looper에 연결된 MessageQueue를 사용하여 작동합니다. 각 Looper 쓰레드는 자체 Choreographer를 가지고 있음을 유의하세요.

# Looper Thread 이해하기

Choreographer가 작동하는 방식을 이해하기 위해서는 우리의 Main Thread 또는 UI Thread가 Looper Thread임을 이해하는 것이 중요합니다.

<div class="content-ad"></div>

루퍼 스레드는 메시지 및 이벤트를 대기하고 처리하는 루프를 계속 실행하는 스레드 유형입니다. Android에서 메인 스레드는 UI 업데이트, 사용자 상호 작용 처리 및 UI에서 수행해야 하는 작업을 담당하는 특별한 루퍼 스레드입니다. 이 스레드는 앱이 응답하도록 유지하며 사용자와 앱 간 상호 작용을 관리합니다.

메인 스레드는 주요 루퍼를 사용하여 연속된 루프를 실행하며 MessageQueue를 기반으로 실행됩니다. 다른 스레드와는 달리 이 MessageQueue는 앱 전체가 종료될 때까지 종료할 수 없습니다.

이 MessageQueue 내에서 Choreographer에 의해 특정 특수 메시지가 처리됩니다. 이러한 메시지들은 UI 업데이트, 애니메이션 및 렌더링의 타이밍 및 동기화를 관리하는 데 중요합니다.

# VSYNC를 이용한 UI 동기화

<div class="content-ad"></div>

VSYNC 신호: VSYNC 또는 수직 동기 펄스는 디스플레이가 새 프레임을 그리기 시작할 준비가 되었음을 나타내는 하드웨어 생성 신호입니다. 이 신호는 디스플레이 업데이트를 화면의 주사율과 동기화하는 데 중요합니다.

Choreographer는 VSYNC 신호를 수신하기 위해 UI 업데이트의 타이밍을 관리합니다. Android OS를 통해 SurfaceFlinger를 통해 DisplayEventReceiver로 이러한 신호를 수신하기위한 수준 낮은 구성 요소를 사용합니다. SurfaceFlinger는 시스템의 컴포지터로 작용하여 디스플레이 하드웨어와 소프트웨어 레이어를 조정합니다. VSYNC 신호가 DisplayEventReceiver로 라우팅되도록 보장하고, 이후 Choreographer에 프레임 업데이트 처리를 알립니다.

아래 순서도는 Android가 VSYNC 신호를 사용하여 UI 업데이트를 관리하는 방법을 설명합니다. 프로세스는 주 스레드가 초기화하고 ValueAnimator를 시작하여 Choreographer와 프레임 콜백을 등록하는 것으로 시작됩니다. 디스플레이 주사율과 동기화를 유지하기 위해 Choreographer은 scheduleVsync()를 호출하여 다음 VSYNC 이벤트를 요청합니다. 이 요청은 DisplayEventReceiver에 의해 처리되며, OS와 통신하여 VSYNC 신호를 수신합니다.

<div class="content-ad"></div>

VSYNC 신호를 수신하면 SurfaceFlinger는 원시 코드에서 dispatchVsync()를 직접 호출하고, 이후 Choreographer의 onVsync()를 호출합니다. Choreographer는 UI를 직접적으로 업데이트하는 대신, MessageQueue에서 doFrame() 메시지를 예약합니다. 이를 통해 MessageQueue에 있는 모든 미처리된 이전 메시지가 프레임을 업데이트하기 전에 처리됩니다. doFrame() 메시지가 처리되면 Choreographer는 ValueAnimator의 프레임 콜백을 포함한 여러 등록된 콜백을 호출하여 애니메이션의 분수를 업데이트하고 새로운 애니메이션 값을 계산하고 UI에 변경 사항을 적용합니다. 애니메이션이 계속 실행 중인 경우, ValueAnimator는 프레임 콜백을 다시 등록하고, 각 프레임에 대해 프로세스가 계속됩니다.

참고: VSYNC 신호를 수신하는 루프는 ValueAnimator의 프레임 콜백에 의존하지 않습니다. 이 루프는 메인 스레드가 활성 상태인 한 계속해서 실행됩니다.

# Choreographer에서의 콜백의 종류

doFrame()이 트리거되면 다음 순서대로 다양한 유형의 콜백이 실행됩니다:

<div class="content-ad"></div>

- 입력 Callbacks: 터치 이벤트 및 키 입력과 같은 사용자 상호 작용을 처리합니다. 이는 UI가 사용자 조작에 빠르게 응답하도록 보장합니다.
- 애니메이션 Callbacks: ValueAnimator 및 사용자 정의 애니메이터로 관리되는 애니메이션을 업데이트합니다. 이 단계에서는 현재 애니메이션 상태를 계산하고 UI 요소에 변경 사항을 적용합니다.
- 트래버스 Callbacks: 뷰 계층 구조의 레이아웃 및 그리기를 관리하며 화면에 뷰의 크기, 위치 및 렌더링을 결정합니다. 창의 루트 뷰로 작용하는 ViewRootImpl은 트래버스 Callback을 수신합니다. 이 콜백이 트리거되면 ViewRootImpl은 performTraversals() 메서드를 호출합니다. 이 메서드는 전체 뷰 계층 구조의 측정, 배치 및 그리기를 담당하며 각 뷰가 화면에 적절히 크기 조정, 위치 조정 및 렌더링된 상태를 보장합니다.
- 커밋 Callbacks: 디스플레이에 대한 변경 사항을 최종 확정 및 커밋합니다.

# 성능 모니터링 및 프레임 속도 조정

Android는 건너뛴 프레임 수를 감지하고 해당 수가 많은 경우 개발자에게 경고하여 성능을 모니터링하는 데 도움이 됩니다. performTraversals() 프로세스의 끝에서 Android는 장치에 대한 선호하는 프레임 속도를 설정합니다. 현재 작업 부하 및 표시되는 콘텐츠에 기반하여 새로 고침 속도를 동적으로 변경함으로써 Android는 배터리 사용량을 최적화하고 전반적인 성능을 향상시킵니다.

# Jetpack Compose에서 애니메이션

<div class="content-ad"></div>

젯팩 캄포즈에서 Animatable 클래스는 MonotonicFrameClock을 활용하여 AndroidUiFrameClock를 주로 사용하여 애니메이션에 일관된 시간 업데이트를 보장합니다. 이 클록 메커니즘은 일반적으로 메인 스레드의 UI Looper와 연결되어 있어 Android의 Choreographer와 매끄럽게 통합될 수 있습니다. 따라서 이 글에서 논의된 ValueAnimator와 Choreographer에 관한 원리와 메커니즘은 젯팩 캄포즈에서 애니메이션이 작동하는 방식에도 적용됩니다.

# 결론

Android 메인 스레드는 메인 루퍼와 연속적인 루프를 실행하는 루퍼 스레드로 작동합니다. 항상 UI 관련 메시지를 처리할 준비가 되어 있습니다. Choreographer는 DisplayEventReceiver를 통해 VSYNC 신호를 수신하고 doFrame() 메시지를 MessageQueue에 포스팅하여 프레임 업데이트를 예약합니다. doFrame()이 처리되면 Choreographer는 다양한 콜백을 트리거하며, 그 중에는 애니메이션용으로도 사용되는 것이 포함됩니다. 이러한 콜백은 ValueAnimator에 신호를 보내어 현재 시간과 애니메이션 지속 시간을 기반으로 분수를 업데이트하도록 합니다. 그 후 ValueAnimator는 애니메이션 값을 업데이트하고 업데이트 콜백을 호출하여 UI를 부드럽게 움직이며 생생하게 만듭니다.

# 마무리

<div class="content-ad"></div>

그게 다야! 우리는 ValueAnimator가 안드로이드 UI를 생동감 있게 만드는 방법을 배웠고, Choreographer가 모든 것을 원할하게 유지하는 방법을 알게 되었으며, 심지어 우리만의 사용자 정의 애니메이터를 만드는 방법도 배웠어요. 

읽어 주셔서 감사합니다! 계속해서 UI를 춤추게 만들어 보세요!

ValueAnimator를 통해 안드로이드 UI를 부드럽게 만드는 방법



<img src="/assets/img/2024-08-26-GetacquaintedwithRubyOnRails_0.png" />

루비 온 레일즈, 종종 친근하게 "레일즈"라고 불리는 것은 약 20년 가까이 널리 사용되고 인정받는 튼튼한 웹 개발 프레임워크입니다. 2004년 David Heinemeier Hansson이 Ruby 프로그래밍 언어를 기반으로 새로운 웹 애플리케이션 개발 프레임워크를 개발했으며, Model-View-Controller 아키텍처 패턴을 따릅니다. 이 프레임워크에 대해 더 알아보기 위해 뛰어들어 루비 온 레일즈에 대해 알아보겠습니다.

# 루비 온 레일즈란 무엇인가요?

루비 온 레일즈는 오픈 소스 웹 애플리케이션 프레임워크입니다. 웹 애플리케이션 개발 프로세스를 보다 간단하게 만드는 것을 목적으로 합니다. 개발자에게 번거로운 반복 코딩 작업을 관리하는 대신 기능을 구조화된 방식으로 작업할 수 있도록 합니다. 이는 Rails를 두 가지 기본 원칙으로 이끕니다:

<div class="content-ad"></div>

- Convention over Configuration (CoC): Rails는 설정보다는 규약을 우선시하는 철학을 채택합니다. 즉, 합리적인 기본 설정이 있어 개발자가 환경을 처음부터 설정할 필요가 없다는 것입니다. 이는 개발 과정을 가속화시키며, 개발자들이 환경 설정에 시간을 들이지 않아도 됩니다.
- Don’t Repeat Yourself (DRY): 이는 재사용 가능하고 유지보수가 쉬운 코드를 작성하는 것을 장려합니다. 중복을 피함으로써 Rails는 코드베이스 내에서 청결함과 분리, 이로 인해 오류가 줄어들고 장기적으로 유지보수가 용이해집니다.

# Ruby on Rails의 주요 기능

Ruby on Rails은 많은 개발자가 주요 도구로 사용하는 매우 기능이 풍부한 프레임워크입니다. Ruby on Rails의 특징 중 몇 가지는 다음과 같습니다:

- MVC 아키텍처: Rails에서는 모델, 뷰, 컨트롤러 세 가지 구성 요소 간에 분리된 프로세스가 존재하여 응용프로그램 로직이 분할되도록 합니다. 이는 코드 베이스가 깨끗하고 조직적으로 유지되도록 보장합니다.
- Active Record: Rails의 ORM 레이어는 Active Record이며, 이를 통해 Ruby 코드를 작성하여 데이터베이스와 상호 작용할 수 있습니다. 이를 통해 데이터베이스와의 상호작용이 CRUD(Create, Read, Update, Delete) 작업에 적합한 깔끔하고 쉬운 방법으로 더욱 접근 가능하게 됩니다.
- RESTful 디자인: Rails는 RESTful 디자인을 지원하며, 개발자들이 RESTful 경로와 액션을 사용하도록 장려합니다. 이는 Rails 애플리케이션을 더욱 예측 가능하고 표준화된 상태로 만들어 줍니다. 이로 인해 확장 가능하고 유지보수가 용이해집니다.
- 내장된 테스트 프레임워크: Rails에는 내장된 테스트 프레임워크가 있으며, 애플리케이션의 테스트를 작성하고 실행하는 것을 간단하게 만들어줍니다. 이는 테스트 주도 개발을 장려하여 코드의 품질을 보장하고 일정 부분 버그 발생 가능성을 줄입니다.
- 젬(Gems): Ruby 커뮤니티는 "젬"이라고 불리는 수천 개의 라이브러리를 개발했는데, 이는 Rails 애플리케이션에 확장 기능을 제공합니다. 인증, 권한 부여부터 결제 처리, 파일 업로드까지 다양한 기능을 포함하고 있는 많은 젬이 있습니다.

<div class="content-ad"></div>

# 루비온레일즈의 장점

루비온레일즈를 특히 유리하게 만드는 많은 이유들이 있습니다. 그래서 개발자들과 비즈니스들 사이에서 명백한 선택이 되었습니다:

- 빠른 개발: 다른 프레임워크들과 비교했을 때 레일즈의 많은 규칙, 자동화 도구, 재사용 가능한 코드 라이브러리들은 개발자들이 애플리케이션을 훨씬 빠르게 구축할 수 있게 합니다.
- 학습 곡선: 레일즈 개발에 사용되는 루비 언어는 매우 가독성이 높고 이해하기 쉽습니다. 레일즈는 이 사용자 친화성을 계승하며, 웹 개발을 시작한 지 얼마 안 된 사람도 쉽게 접근할 수 있습니다.
- 확장성: 레일즈는 매우 높은 트래픽을 처리하도록 설계되었습니다. 적절한 최적화와 인프라는 레일즈 애플리케이션을 수요 증가에 따라 적절하게 확장하게끔 허용합니다.
- 거대한 커뮤니티 지원: 레일즈 커뮤니티는 매우 활발합니다. 계속해서 더 나아지도록 기여하고 있어, 커뮤니티 내 지원은 레일즈가 웹 개발의 최신 기술과 부담을 지속적으로 따라잡을 것을 의미합니다.
- 보안: 레일즈는 자체 기능 내에서 SQL 인젝션, XSS, CSRF에 대한 보호 기능을 포함하고 있습니다. 이는 개발자들이 안전한 애플리케이션을 구축하는 데 도움을 줍니다.

# 루비온레일즈로 개발된 인기 애플리케이션

<div class="content-ad"></div>

유역의 회사들과 스타트업들이 웹 애플리케이션을 만들 때 루비 온 레일즈를 선택한 이유는 그 유연성, 사용 편의성, 그리고 강력한 애플리케이션을 구현할 수 있는 능력 때문입니다. 예를 들어:

- GitHub: 세계에서 가장 유명한 코드 호스팅 업체로서, 버전 관리와 협업 소프트웨어 개발의 양대 산맥인 GitHub은 루비 온 레일즈로 구축되어 있어 대규모 애플리케이션을 제작하는 능력을 입증하고 있습니다.
- Shopify: 수백만 개의 비즈니스 및 다양한 웹 애플리케이션을 구동하는 가장 고급 전자 상거래 시스템인 Shopify은 루비 온 레일즈를 사용하여 복잡하고 고트래픽 웹사이트를 효율적으로 처리할 수 있음을 입증하고 있습니다.
- Airbnb: 매우 인기 있는 휴가 임대 플랫폼인 Airbnb은 개발 초기 단계부터 루비 온 레일즈를 사용하였으며 시간이 지남에 따라 스케일 아웃해야 하는 모든 MVP에 완벽하게 부합된다는 것을 증명하고 있습니다.
- Basecamp: 루비 온 레일즈를 만든 사람이 개발한 프로젝트 관리 도구인 Basecamp은 프레임워크가 우수하고 확장 가능한 애플리케이션을 구축할 수 있는 능력을 입증하고 있습니다.

# 루비 온 레일즈로 시작하기

루비 온 레일즈를 사용하여 애플리케이션을 만들기 시작하려면 다음 단계만 수행하면 됩니다:

<div class="content-ad"></div>

- 루비 설치: Rails는 루비 프레임워크이므로 루비 언어를 먼저 설치해야 합니다. 가장 쉬운 방법은 공식 웹사이트에서 언어를 직접 다운로드하는 것입니다. 또는 다른 유틸리티인 RVM이나 rbenv와 같은 것을 다운로드하여 다양한 버전을 관리할 수 있습니다.
- Rails 설치: 루비를 설치했다면 터미널에서 gem install rails 명령을 작성하고 실행하여 Rails를 설치할 수 있습니다.
- 새 Rails 애플리케이션 생성: rails new myapp 명령을 실행하여 새로운 애플리케이션을 만듭니다. 이 명령은 애플리케이션에 필요한 기본 파일 구조가 있는 디렉토리를 생성합니다.
- 서버 시작: 애플리케이션 디렉토리에서 rails server를 실행하여 로컬 개발 서버를 시작합니다. 그런 다음 브라우저에서 http://localhost:3000으로 이동하여 앱을 확인할 수 있습니다.
- 개발 시작: 모델, 뷰, 컨트롤러: 모델, 뷰 및 컨트롤러를 구축하여 기능 개발을 진행합니다. Rails의 도구와 내장 생성기를 사용하여 개발 속도를 높일 수 있습니다.

루비 온 레일즈는 여전히 선호되는 이유는 쉽고 거대한 커뮤니티의 지원을 받을 수 있기 때문입니다. 소규모 비즈니스 웹사이트에서부터 대용량 웹 애플리케이션까지 Rails가 제공하는 필요한 것들로 효과적으로 작업할 수 있습니다. Rails는 설정보다는 관습 및 DRY 원칙을 통해 개발자들을 강화시키며 현재까지 이어지고 있습니다. Ruby on Rails의 기본을 배우고 이 견고한 웹 프레임워크로 애플리케이션을 개발하면서 생태계를 깊이 파고들어가보세요.

루비 온 레일즈로 시작하는 웹 개발 기초



<img src="/assets/img/2024-08-26-HowtoinstallRubywithrbenvinWindows11WSL-Ubuntu2004distro_0.png" />

윈도우 11 WSL-Ubuntu 20.04 배포본에 완전한 Ruby를 설치하는 데 사용한 단계입니다.

- 필수 패키지 설치

```js
$ sudo apt-get update
```

<div class="content-ad"></div>

2. rbenv 복제하기

```js
$ git clone https://github.com/rbenv/rbenv.git ~/.rbenv
```

3. rbenv 플러그인 복제하기

```js
$ git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build
$ git clone https://github.com/rkh/rbenv-whatis.git ~/.rbenv/plugins/rbenv-whatis
$ git clone https://github.com/rkh/rbenv-use.git ~/.rbenv/plugins/rbenv-use
```

<div class="content-ad"></div>

참고:

만약 이 메시지를 받았다면:

```js
fatal: unable to access 'https://github.com/rbenv/ruby-build.git/': gnutls_handshake() failed: The TLS connection was non-properly terminated.
```

터미널에서 이 스크립트를 먼저 실행해야 할 수도 있습니다:

<div class="content-ad"></div>

```js
$ sudo apt-get install -y libcurl4-openssl-dev
```

4. rbenv 유틸리티 컴파일

```js
$ cd ~/.rbenv && src/configure && make -C src
```

참고:

<div class="content-ad"></div>

만약 위의 명령을 실행한 후 이 메시지를 보게 된다면, 먼저 이 스크립트를 실행해야 할 수도 있습니다:

```bash
$ sudo apt-get install build-essential
```

5. PATH에 rbenv 추가하기

```bash
$ echo 'export PATH=$HOME/.rbenv/bin:$PATH' >> ~/.bash_profile
```

<div class="content-ad"></div>

6. ~/.bash_profile 파일의 끝에 이 줄을 추가해주세요.

```js
eval "$(rbenv init -)"
```

7. rbenv를 설치한 사용자로 로그아웃 후 다시 로그인하여 모든 것이 제대로 작동하는지 확인해주세요.

```js
$ exit
$ su -l <your_username>
```

<div class="content-ad"></div>

8. 모든 사용 가능한 Ruby 버전을 나열하여 rbenv를 확인해보세요.

```js
$ rbenv install -l
```

9. Ruby의 버전을 설치하세요.

```js
$ rbenv install 3.1.1
```

<div class="content-ad"></div>

에러 메시지를 받은 경우 다음과 같은 스크립트를 먼저 실행해야 할 수 있습니다:

```js
$ apt-get install -y libssl-dev zlib1g-dev
```

<div class="content-ad"></div>

10. 이 스크립트를 실행하세요

```js
$ rbenv rehash
```

11. 설치된 루비 버전들을 나열합니다

```js
$ rbenv versions
  3.1.1
```

<div class="content-ad"></div>

12. 루비의 로컬 버전을 설정하세요

```js
$ rbenv local 3.1.1
```

13. 또는, 루비의 글로벌 버전을 설정하세요

```js
$ rbenv global 3.1.1
```

<div class="content-ad"></div>

14. 루비 버전 표시

```js
$ ruby -v
```

15. 젬 버전 표시

```js
$ gem -v
```

Windows 11의 WSL-Ubuntu 20.04 배포판에서 rbenv를 사용해 Ruby를 설치하는 방법

![image](/assets/img/2024-08-26-UnderstandingMVCArchitectureinRubyonRails_0.png)

# 소개

웹 개발을 막 시작한 분이라면, Ruby on Rails를 연구할 때 "MVC"라는 용어를 들어봤을 것입니다. MVC가 무엇을 의미하며, 더 중요한 것은 무엇을 하는 걸까요? 이 게시물에서는 MVC(Model-View-Controller) 아키텍처의 기본을 설명합니다. 기술적 배경이 없는 사람도 쉽게 이해할 수 있도록 매우 단순한 수준으로 분해해서 설명할 것입니다.

# MVC 아키텍처란 무엇인가?


<div class="content-ad"></div>

MVC는 Model-View-Controller의 약자입니다. 사실, 이는 응용 프로그램의 구조를 분리하는 디자인 패턴입니다. 이 패턴은 응용 프로그램을 세 가지 연결된 구성 요소로 분할하며, 각각을 응용 프로그램의 특정 부분으로 분할합니다. 이러한 구성 요소를 분해하면 다음과 같습니다:

- Model: 데이터와 비즈니스 로직을 관리합니다.
- View: 사용자 인터페이스와 프레젠테이션을 관리합니다.
- Controller: Model과 View 사이의 인터페이스 역할을 하여 응용 프로그램의 동작을 제어하며 명령을 처리하거나 데이터를 관련시킴으로써 동작합니다.

<div class="content-ad"></div>

MVC 구성 요소를 사용하여이 애플리케이션을 나누면 개발자가 애플리케이션을 더 효과적으로 처리하고 확장할 수 있습니다.

## MVC의 다양한 구성 요소

루비 온 레일즈를 사용한 구현에서 각 요소를 간략히 살펴보고 어떻게 함께 작동하는지 살펴보겠습니다.

- Model: 데이터 및 비즈니스 로직

<div class="content-ad"></div>

MVC에서 모델은 애플리케이션의 데이터 부분을 의미합니다. 이 데이터는 데이터의 형태부터 데이터를 저장하거나 관리하는 방법까지 무엇이든 될 수 있습니다. Ruby on Rails에서는 모델이 주로 데이터베이스 상호작용에 사용됩니다.

예를 들어 블로그를 만들고 있다면, 아마도 게시물에 대한 모델을 가지고 있을 것입니다. 게시물 모델은 블로그 게시물이 포함해야 할 데이터를 정의합니다. 예를 들어 제목, 내용, 작성자 등이 있으며, 블로그 게시물을 저장하고 업데이트하며 데이터베이스에서 가져오기 위한 메서드가 포함될 것입니다.

데이터 저장: 데이터 구조와 데이터베이스가 데이터를 저장하는 방법을 정의합니다.

데이터 유효성 검사: 데이터가 저장되기 전에 특정 기준을 충족시키는지 확인합니다.

<div class="content-ad"></div>

비즈니스 로직: 어플리케이션이 필요로 하는 몇 가지 규칙을 준수하고 일부 계산을 수행합니다.

Rails에서는 ActiveRecord 라이브러리를 사용합니다. 이 라이브러리는 모델과 관련된 대부분의 문제를 처리합니다 — 다시 말해, 데이터베이스와 상호 작용하기 위한 메서드를 제공합니다. 이는 데이터 작업을 훨씬 쉽게 만들어 줍니다.

```js
# app/models/post.rb
class Post < ApplicationRecord
 # 제목과 내용의 존재 여부를 보장하는 유효성 검사
 validates :title, presence: true, length: { minimum: 5 }
 validates :body, presence: true, length: { minimum: 15 }
 
 # 다른 모델과의 관계 설정 (예: User 모델)
 belongs_to :user
end
```

2. 뷰: 이것은 사용자 인터페이스입니다.

<div class="content-ad"></div>

뷰(View)는 사용자가 주로 볼 수 있거나 상호 작용할 수 있는 부분입니다. 사용자에게 데이터를 특정 형식으로 표시하는 데 관심이 있는 부분입니다. 웹 애플리케이션에서는 일반적으로 사용자 브라우저에서 제시된 HTML 페이지에 표시됩니다.

간단한 블로그 예제로 돌아가보면, 뷰는 블로그 게시물 목록을 표시하거나 새 게시물을 작성하는 양식을 표시하는 템플릿일 수 있습니다. 뷰 자체는 많은 작업을 수행하지 않습니다. 단순히 컨트롤러가 제공한 데이터를 가져와 사용자에게 전달하는 역할을 합니다.

뷰의 주요 책임은 다음과 같습니다:

- 사용자 인터페이스: 사용자가 이해할 수 있는 방식으로 데이터를 표시하기

<div class="content-ad"></div>

템플릿: 데이터의 표현 방법을 설명하며, 일반적으로 HTML, CSS 및 내장 루비(ERB)를 사용하여 Rails에서 처리합니다.

상호작용: 폼 및 버튼과 같은 사용자 입력을 다루는 방법

Rails에서 뷰는 대부분 HTML과 루비 코드의 조합인 ERB로 생성됩니다. 이를 통해 HTML에 직접적으로 루비 코드를 삽입할 수 있습니다.

```js

<h1>모든 포스트</h1>

<% @posts.each do |post| %>
  <div class="post">
    <h2><%= link_to post.title, post_path(post) %></h2>
    <p><%= truncate(post.body, length: 100) %></p>
    <p><%= post.user.name %> 님이 게시함</p>
  </div>
<% end %>
```

<div class="content-ad"></div>

3. **컨트롤러**: 어플리케이션의 두뇌

컨트롤러는 모델과 뷰 사이의 다리 역할을 합니다. 주로 모델의 도움을 받아 사용자 입력을 받은 후, 무엇을 사용자에게 정확히 보여줄지를 결정하는 것이 기본적인 역할입니다. 요약하면, 이것이 어플리케이션에서의 "두뇌", 의사결정자입니다.

예를 들어, 사용자가 블로그 글 목록을 보고 싶어 할 때, 컨트롤러는 포스트 모델로부터 필요한 데이터를 요청하고, 그 목록을 보여줄 뷰를 렌더링합니다. 사용자가 새로운 블로그 글을 제출하면, 컨트롤러는 해당 데이터를 가져와 모델을 사용하여 데이터베이스에 저장한 후 사용자를 업데이트된 글 목록으로 리디렉션합니다.

컨트롤러의 중요한 역할은:

<div class="content-ad"></div>

요청 처리: 사용자로부터 입력을 받아들이는 것은 HTTP 요청과 관련이 있습니다.

데이터 처리: 데이터는 모델을 사용하여 조작되거나 검색됩니다.

뷰 렌더링: 데이터와 사용자의 입력에 기초하여 어떤 뷰를 렌더링할지 결정합니다.

Rails에서 이러한 것들은 ApplicationController에서 상속된 Ruby 클래스입니다. 컨트롤러의 각 메서드는 작업으로, 각 작업은 사용자에게 무언가를 제공합니다: 뷰, 새로운 양식 또는 편집 양식을 포함할 수 있습니다.

<div class="content-ad"></div>

```js
# app/controllers/posts_controller.rb
class PostsController < ApplicationController
  # 모든 게시물을 표시하는 액션
  def index
    @posts = Post.all
  end

  # 단일 게시물을 표시하는 액션
  def show
    @post = Post.find(params[:id])
  end

  # 새로운 게시물을 생성하는 액션
  def new
    @post = Post.new
  end
end
```

# 루비 온 레일스에서 MVC가 어떻게 함께 작동하는지

이제 MVC의 세 가지 구성 요소를 모두 다루었으니, 전형적인 레일스 애플리케이션에서 이들이 어떻게 함께 작동하는지 살펴보겠습니다.

블로그 웹사이트를 방문하는 사용자를 고려해 보겠습니다. MVC가 요청을 처리하는 방법은 다음과 같습니다: 사용자 요청(컨트롤러) 사용자가 블로그 글 목록을 보기 위해 홈페이지로 이동합니다. 사용자의 웹 요청은 레일스 애플리케이션으로 전달됩니다. 이 요청은 컨트롤러 액션으로 보내집니다. 예를 들어, PostsController#index와 같습니다.


<div class="content-ad"></div>

요청 처리하기 (모델 및 컨트롤러): PostsController의 index 액션은 데이터베이스에서 모든 포스트를 검색하기 위해 Post 모델을 사용합니다.

뷰 렌더링하기 (컨트롤러 및 뷰): 컨트롤러는 이 포스트 목록을 index.html.erb 뷰 템플릿에 전달합니다. 이 erb 템플릿은 HTML로 렌더링되어 사용자의 브라우저로 다시 전송됩니다.

결과 표시하기 (뷰): HTML이 사용자의 브라우저로 전송되고 모든 블로그 포스트 목록이 화면에 사용자에게 표시됩니다.

컨트롤러는 흐름을 관리하고, 모델은 데이터를 나타내며, 뷰는 정보를 사용자에게 보여줍니다.

<div class="content-ad"></div>

# 루비 온 레일즈에서 MVC를 사용하는 이유

루비 온 레일즈의 MVC 아키텍처를 사용하면 복잡한 웹 애플리케이션을 개발할 때 여러 부분을 분리하여 다룰 수 있습니다. 여기에는 다음과 같은 장점이 있습니다:

- 관심사의 분리

관심사의 분리는 MVC의 가장 큰 장점 중 하나여야 합니다. 전체 애플리케이션을 세 가지 매우 다른 부분으로 분리할 수 있으며, 서로 다른 사람들이 독립적으로 애플리케이션의 각 부분에서 작업을 시작할 수 있습니다. 이는 애플리케이션을 관리하고 확장하는 데 더 간단하게 만들어 줍니다. 특히 애플리케이션 복잡성이 증가하는 시기에 이점이 있습니다.

<div class="content-ad"></div>

예를 들어, 프론트엔드 개발자는 데이터가 어떻게 가져오거나 저장되는지에 관심이 없어도 뷰에서 작업을 수행할 수 있습니다. 반면에 백엔드 개발자는 모델 및 컨트롤러에서 작업을 수행하여 데이터가 올바르게 처리되도록 합니다.

2. 재사용성과 유연성

각 구성 요소가 독립적이기 때문에 MVC 아키텍처에서 코드를 재사용하고 유지보수하는 것이 더 쉽습니다. 데이터 표시 방식을 변경하려면 모델과 컨트롤러를 신경 쓰지 않고 새 뷰만 만들면 됩니다. 마찬가지로 처리 방식을 변경해야 하는 경우에는 뷰가 아닌 모델을 업데이트하면 됩니다.

모듈화 또한 새로운 기능이나 변경 사항을 추가하는 것을 더 쉽게 만듭니다. 예를 들어, 블로그 작업 중에 새 페이지를 추가하려는 경우 새 컨트롤러 액션과 뷰 템플릿을 만들기만 하면 됩니다. 전체 애플리케이션을 변경할 필요가 없습니다.

<div class="content-ad"></div>

애플리케이션이 점점 커짐에 따라 유지 보수와 확장이 더 어려워지는데요. 여기서 MVC가 도움이 되는 거죠. 코드를 특정한 방식으로 조직화하면 더 쉽게 관리할 수 있습니다. 각 구성 요소가 하나의 역할을 갖고 있기 때문에 버그를 빨리 찾아 고칠 수 있습니다. 또한 기존 기능을 손상시키지 않고 새로운 기능을 추가할 수 있습니다.

이로써 대규모 그룹에서는 분업이 명확하게 이루어지므로 협력이 촉진됩니다. 이를 통해 프로젝트 구성원들의 작업을 동시에 진행할 수 있어 전체 개발 시간을 최소화하고 생산성을 극대화할 수 있습니다.

3. 테스트 용이성

테스트는 애플리케이션을 구축하는 핵심 부분입니다. MVC 아키텍처를 통해 애플리케이션을 테스트하는 것이 정말 쉬워집니다. 모든 구성 요소가 독립적이기 때문에 각각을 별도로 테스트할 수 있습니다. 따라서 오류를 조기에 발견하고 애플리케이션이 가정대로 작동하는지 확인할 수 있습니다.

<div class="content-ad"></div>

# Ruby on Rails를 사용한 MVC의 실제 예시

실제로 MVC를 사용하여 어떻게 구현되는지에 대해 더 잘 이해하기 위해, 아래는 전자 상거래 웹사이트의 예시입니다.

1. 전자 상거래 웹사이트

예를 들어, Ruby on Rails를 사용하여 전자 상거래 사이트를 구축한다고 가정해보겠습니다. 이 경우, 다음이 여러분의 MVC가 될 것입니다:

<div class="content-ad"></div>

모델: 제품, 주문, 고객을 위한 모델이 있을 것입니다. 이 모델은 데이터의 구조를 정의하고 데이터베이스와 상호작용하는 방법을 포함합니다.

뷰: 뷰는 제품 목록, 쇼핑 카트, 심지어 주문 확인과 같은 템플릿으로 구성됩니다. 이러한 템플릿은 사용자에게 데이터를 제공하고 사용자 입력을 처리합니다. 예를 들어, 제품을 장바구니에 추가하는 경우와 같은 작업을 다룹니다.

컨트롤러: 컨트롤러는 애플리케이션의 흐름을 관리합니다. 예를 들어, ProductsController는 제품 목록을 보는 모든 요청을 관리하고, OrdersController는 결제 프로세스를 관리합니다.

# 루비 온 레일스에서 MVC의 단점

<div class="content-ad"></div>

MVC 프레임워크는 많은 혜택을 제공하지만 일정 수준의 복잡성도 함께 가지고 있습니다. 여기서 몇 가지 문제를 살펴봅시다.

1. 대규모 응용프로그램의 복잡성

응용프로그램의 규모와 복잡성이 증가함에 따라 MVC 구성 요소를 다루는 것이 상당히 어려워집니다. 컨트롤러는 과도한 로직을 축적하게 되어 유지 관리가 어려워집니다. 때때로 "fat controllers" 또는 "fat models"로 불리기도 합니다.

2. 성능 오버헤드

<div class="content-ad"></div>

가끔 MVC에서 채택된 엄격한 관심사 분리는 성능에 부담을 줄 수 있습니다. 예를 들어, 뷰를 렌더링하는 동안 하나 이상의 데이터베이스 쿼리가 필요할 수 있어 전체 애플리케이션 성능이 저하될 수 있습니다.

# 결론

루비 온 레일즈의 기본 기반은 MVC에 근간을 두고 있으며, 이것은 웹 애플리케이션 개발 방식을 심도있게 정의했습니다. MVC는 애플리케이션을 모델, 뷰 및 컨트롤러 세 가지 주요 구성 요소로 분할합니다. 이로써 복잡한 애플리케이션을 더 쉽고 더 짧은 시간에 개발하기 위한 명확한 구조를 제공합니다.

MVC의 이점인 관심사 분리, 재사용성, 유지보수성, 테스트 용이성은 웹 개발자들에게 강력한 도구로 작용했습니다.

<div class="content-ad"></div>

MVC 아키텍처를 이해하고 정복한 후에는 견고하고 확장 가능한 응용 프로그램을 구축할 수 있게 될 거예요. 그러니 깊게 파고들고, 개발을 시작하고, 그 힘을 실제로 경험해 보세요!

루비 온 레일즈에서 MVC 아키텍처 설계하는 방법



![Partitioned Table](/assets/img/2024-08-26-FromPitfallstoBestPracticesWorkingwithPartitionedTablesinRails_0.png)

파티션이 분할된 테이블을 생성하거나 업데이트하는 방법에 대한 가이드는 많지만, 작업하는 데 주의해야 할 점 및 도전 과제에 대한 정보는 거의 제공되지 않습니다. 이에 대한 좋은 예는 있지만, 오늘은 파티션이 분할된 테이블을 안전하고 효율적으로 다루는 방법에 대한 제 경험을 공유하고 싶습니다.

# 파티션 간 순차 스캔

가장 빈번하고 명백하지 않은 문제는 일반적인 DB 성능 측정 지표로는 알 수 없기 때문입니다. 순차 스캔은 쿼리가 파티션 구조를 최대한 활용하지 못할 때 주로 발생합니다. 관련 파티션만 스캔하는 대신, 데이터베이스는 모든 파티션을 스캔하여 성능을 크게 저하시킵니다.
SQL 쿼리를 수동으로 작성할 때 이 문제를 피하는 것은 비교적 쉽습니다. 파티션 키의 사용을 명시적으로 제어할 수 있기 때문입니다. 그러나 Rails에서는 일반적으로 SQL을 추상화하는 ActiveRecord를 사용하므로 생성된 쿼리를 자주 보지 못합니다.

<div class="content-ad"></div>

테이블이 created_at 필드로 분할된 일반적인 예시를 살펴봅시다:

```js
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    avatar_id INTEGER NOT NULL,
    created_at TIMESTAMP NOT NULL
) PARTITION BY RANGE (created_at);

CREATE TABLE users_2023_q1 PARTITION OF users
    FOR VALUES FROM ('2023-01-01') TO ('2023-04-01');

CREATE TABLE users_2023_q2 PARTITION OF users
    FOR VALUES FROM ('2023-04-01') TO ('2023-07-01');
```

사용자의 created_at 값을 지정하지 않고 사용자를 검색할 때 파티션 스캔이 발생할 것임을 쉽게 예상할 수 있습니다:

```js
# User.find(123)
EXPLAIN ANALYZE SELECT * FROM users WHERE id = 123 LIMIT 1;
...
Seq Scan on users_2023_q1  (cost=0.00..35.50 rows=5 width=100) (actual time=0.005..0.005 rows=0 loops=1)
Seq Scan on users_2023_q2  (cost=0.00..35.50 rows=5 width=100) (actual time=0.005..0.005 rows=0 loops=1)
...
# User.last(10)
...
Seq Scan on users_2023_q1  (cost=0.00..35.50 rows=5 width=100) (actual time=0.005..0.005 rows=0 loops=1)
Seq Scan on users_2023_q2  (cost=0.00..35.50 rows=5 width=100) (actual time=0.005..0.005 rows=0 loops=1)
...
```

<div class="content-ad"></div>

그러나 객체를 다룰 때도 동일한 순차 검색을 받게 된다는 점은 명확하지 않을 수 있습니다:

```js
# user = User.find_by(id: 123, created_at: '2023-01-01')
SELECT * FROM users WHERE id = 123, created_at = '2023-01-01' LIMIT 1;
# 파티션별로 seq scan 없음
# user.update(avatar_id: 123)
EXPLAIN ANALYSE UPDATE users SET avatar_id = 123 WHERE id = 123;
...
Seq Scan on users_2023_q1  (cost=0.00..35.50 rows=5 width=100) (actual time=0.005..0.005 rows=0 loops=1)
Seq Scan on users_2023_q2  (cost=0.00..35.50 rows=5 width=100) (actual time=0.005..0.005 rows=0 loops=1)
...
```

관계를 통해 사용자를 선택할 때도 동일한 문제가 발생합니다:

```js
# avatar = Avatar.find(123)
# user = avatar.user
SELECT * FROM users WHERE avatar_id = 123 LIMIT 1;
...
Seq Scan on users_2023_q1  (cost=0.00..35.50 rows=5 width=100) (actual time=0.005..0.005 rows=0 loops=1)
Seq Scan on users_2023_q2  (cost=0.00..35.50 rows=5 width=100) (actual time=0.005..0.005 rows=0 loops=1)
...
```

<div class="content-ad"></div>

ActiveRecord가 파티션을 완전히 지원하지 않아서 ActiveRecord 쿼리를 사용하는 방식과 해당 쿼리가 순차 스캔을 생성하는지 여부를 주의해야 합니다.

해결 방법:

ActiveRecord에서 제공하는 각종 편의 기능을 최소화하고 필요한 파티션을 찾는 데 도움이 될 수 있도록 명시적인 파티션 키를 사용해야 합니다:

```js
user = User.find_by(id: 123, created_at: '2023-01-01')
User.where(id: user.id, created_at: user.created_at).update_all(avatar_id: 123)

avatar = Avatar.find(123)
user = User.where(avatar_id: avatar.id, created_at: '2023-01-01')
```

<div class="content-ad"></div>

# 비효율적인 upsert_all 사용

레일즈에서 파티션 테이블을 다룰 때 또 다른 공통 문제는 upsert_all 메서드의 비효율적인 사용입니다. 이 문제는 upsert_all이 기본적으로 파티션 테이블에 최적화되어 있지 않기 때문에 발생합니다. 파티션 키가 unique_by 제약 조건이나 쿼리의 WHERE 절에 포함되지 않은 경우, PostgreSQL은 기록을 삽입하거나 업데이트할 올바른 파티션을 찾기 위해 모든 파티션을 스캔해야 할 수도 있습니다. 이는 여러 파티션을 가로지르는 불필요한 순차 스캔으로 인해 상당한 성능 저하를 초래할 수 있습니다.

이제 upsert_all을 사용하여 여러 사용자를 업데이트하려고 한다고 가정해 봅시다. 이 예제에서 unique_by: :id는 파티션 키(created_at)를 포함하지 않기 때문에 PostgreSQL은 올바른 파티션을 찾기 위해 모든 파티션을 스캔해야 할 수 있습니다:

```js
# User.upsert_all([
#   { id: 123, avatar_id: 456, created_at: '2023-01-15' },
#   { id: 124, avatar_id: 789, created_at: '2023-05-10' }
# ], unique_by: :id)

EXPLAIN ANALYZE
INSERT INTO users (id, avatar_id, created_at)
VALUES (123, 456, '2023-01-15'), (124, 789, '2023-05-10')
ON CONFLICT (id)
DO UPDATE SET avatar_id = EXCLUDED.avatar_id;
...
Seq Scan on users_2023_q1  (cost=0.00..35.50 rows=1 width=100) (actual time=0.005..0.005 rows=1 loops=1)
Seq Scan on users_2023_q2  (cost=0.00..35.50 rows=1 width=100) (actual time=0.005..0.005 rows=1 loops=1)
...

<div class="content-ad"></div>

문제를 피하는 방법:

upsert_all을 사용할 때 unique_by 절에 항상 파티션 키를 포함하세요. 이렇게 하면 PostgreSQL이 올바른 파티션을 효율적으로 찾아 삽입 또는 업데이트를 적용할 수 있으며 관련 없는 파티션을 스캔하지 않습니다:

# User.upsert_all([
#   { id: 123, avatar_id: 456, created_at: '2023-01-15' },
#   { id: 124, avatar_id: 789, created_at: '2023-05-10' }
# ], unique_by: %i[id created_at])

EXPLAIN ANALYZE
INSERT INTO users (id, avatar_id, created_at)
VALUES (123, 456, '2023-01-15'), (124, 789, '2023-05-10')
ON CONFLICT (id, created_at)
DO UPDATE SET avatar_id = EXCLUDED.avatar_id;

# 외부 키와 관련 자식 항목 처리하기

<div class="content-ad"></div>

파티션이 지정된 테이블과 연관 관계를 설정하는 것은 조금 까다로울 수 있습니다. ActiveRecord의 연관 관계(belongs_to, has_many 등)는 파티셔닝을 자동으로 처리해주지 않습니다. 특히 연관 관계에 파티션 키가 포함되지 않은 경우, 여러 파티션을 스캔하는 비효율적인 쿼리가 발생할 수 있습니다.

또한 파티션이 지정된 테이블을 다른 테이블과 조인하는 경우, 조인 조건에 파티션 키가 포함되지 않으면 복잡하고 느린 쿼리가 발생할 수 있습니다. 특히 조인이 여러 파티션에 흩어진 대규모 데이터 집합을 처리해야 할 때 문제가 될 수 있습니다.

다음은 이러한 문제를 피하는 방법입니다:

# 파티션 키를 사용하여 사용자 및 그들의 아바타를 가져오기
users_with_avatars = User.joins(:avatar)
                         .where("avatars.id = ? AND users.created_at = ?", 456, '2023-01-15')

<div class="content-ad"></div>

# Rails에서 분할된 테이블을 사용하는 최상의 방법

쿼리 최적화:

- 항상 EXPLAIN을 사용하여 분할된 테이블에서 쿼리의 성능을 분석하십시오. 또한 쿼리가 연속 스캔을 생성하는지 여부를 확인하는 유일한 방법이거나 거의 그렇습니다.
- 파티션 키를 포함하는 인덱싱 전략을 구현하여 쿼리가 특정 파티션을 대상으로 할 수 있도록 합니다.
- 파티션 키별로 명시적으로 필터링하는 쿼리를 작성하여 모든 파티션에 대해 불필요한 스캔을 피하십시오.

대량 삽입 및 업데이트 처리:

<div class="content-ad"></div>

- 대량 작업을 효율적으로 관리하기 위해 작은 배치로 나누어 처리하세요.
- upsert_all을 사용할 때는 성능 병목 현상을 피하기 위해 파티션 키를 포함시켜 주의깊게 사용하세요.

마이그레이션 관리:

- 파티션된 환경에서 스키마 변경이 각 분할에 적용되어야 하므로 마이그레이션 계획을 신중히 세우세요.
- 복잡한 작업에 대해 raw SQL을 사용하고 파티션을 추가, 제거 또는 수정할 때 데이터 무결성과 성능에 미치는 영향을 고려하세요.

테스트와 모니터링:

<div class="content-ad"></div>

- 제작 환경과 유사한 스테이징 환경에서 파티셔닝된 테이블 설정을 철저히 테스트하세요.
- 생산 환경에서 쿼리 및 작업이 효율적으로 실행되는지 모니터링 도구를 사용하여 파티션 성능을 확인하세요.

# 결론

파티션된 테이블을 사용하면 대규모 테이블의 지연 시간을 줄이는 좋은 도구가 될 수 있습니다. 하지만 실수하기 쉬우므로 조심히 사용해야 합니다. 이 내용이 Rails에서 파티션된 테이블을 다루는 방법을 이해하는 데 도움이 되었기를 바랍니다.

파티션 테이블을 다루는 Rails에서의 함정과 모범 사례



아래는 당신의 Rails 어플리케이션이 비즈니스 로직이 컨트롤러와 모델에 서서히 들어가는 것과 관련하여 원활히 진행되고 있다는 것을 보여줍니다. 이것들은 시스템의 기본 구성 요소이며, 여기서 서비스 객체가 주요한 역할을 합니다. 그들의 주요 관심사는 코드베이스 내에서 순서를 유지하는 것입니다. 이제 여러분에게 Rails 어플리케이션에서 서비스 객체를 구현하는 방법을 보여드리겠습니다.

## 왜 우리는 서비스 객체를 정당화할까요:

그러나 약간의 배경 지식은 나중에 참고하기 위한 참조로 매우 도움이 되겠습니다. 서비스 객체 및 유사한 개념이 왜 필요한지에 대해 간단히 설명하겠습니다. 이들은 여러분에게 다음과 같은 기능을 제공합니다:

<div class="content-ad"></div>

- 역할 분리 된 비즈니스 로직: 컨트롤러와 모델은 각각의 가장 중요한 기능에만 집중해야 합니다.
- 테스트 용이성 향상: 비즈니스 로직을 쉽게 테스트하거나 상수를 노출시키지 않고 테스트를 작성할 수 있습니다.
- 투명성 향상: 자체 문서화가 된 깔끔한 코드를 작성하여 프로젝트 수명 동안 유지 보수하기 쉽게 만듭니다!

서비스 객체 — 서비스 객체는 하나의 책임만을 가지도록 의도되었거나 다른 말로 하면 한 가지만을 수행하거나 일부 업무 지식을 포함해야 합니다. 이는 깔끔하고 정리가 잘 된 코드를 유지하는 많은 층위가 있는 응용 프로그램에 대해 매우 유용한 도구가 됩니다.

## 단계 1: 설정

이미 Rails 앱이 없는 경우 새로 만들어 보겠습니다. 터미널을 열고 다음 명령을 실행하세요:

<div class="content-ad"></div>

```js
rails new service_objects_demo
cd service_objects_demo
```

이렇게 하면 service_objects_demo라는 이름의 새로운 Rails 애플리케이션이 생성되고 프로젝트 디렉토리로 이동합니다.

## 단계 2: 서비스 객체 생성

유저 생성을 위한 서비스 객체를 생성해보겠습니다. CreateUserService라고 부르겠습니다. 먼저 서비스 객체를 위한 디렉토리가 있는지 확인해주세요. 아직 없다면 생성해주세요:

<div class="content-ad"></div>


```js
mkdir app/services
```

이제, CreateUserService 클래스를 만들어보겠습니다. 이 서비스는 사용자를 생성하는 논리를 처리할 것입니다:

```js
# app/services/create_user_service.rb
class CreateUserService
  def initialize(user_params)
    @user_params = user_params
  end

  def call
    user = User.new(@user_params)
    if user.save
      user
    else
      user.errors.full_messages
    end
  end
end
```

여기서 CreateUserService 클래스는 사용자 매개변수를 인수로 사용하여 새로운 사용자를 만들려고 시도하고 성공하면 사용자를 반환하거나 실패하면 오류 메시지를 반환합니다.


<div class="content-ad"></div>

## 단계 3: 서비스 객체를 컨트롤러에서 사용하기

이제 서비스 객체를 UsersController에서 활용해 봅시다. 다음은 create 액션에서 사용하는 방법입니다:

```js
# app/controllers/users_controller.rb
class UsersController < ApplicationController
  def create
    service = CreateUserService.new(user_params)
    result = service.call

    if result.is_a?(User)
      render json: result, status: :created
    else
      render json: { errors: result }, status: :unprocessable_entity
    end
  end

  private

  def user_params
    params.require(:user).permit(:name, :email, :password, :password_confirmation)
  end
end
```

서비스 객체를 사용함으로써 컨트롤러의 create 액션은 주로 HTTP 요청 및 응답을 처리하는 주요 역할에 더 집중할 수 있습니다.

<div class="content-ad"></div>

## 단계 4: 더 많은 서비스 객체 추가하기

이제, 다른 사용자 관련 작업을 처리하기 위해 몇 가지 더 많은 서비스 객체를 생성해 봅시다: ShowUserService, UpdateUserService, 그리고 ForgotPasswordService.

ShowUserService:

```js
# app/services/show_user_service.rb
class ShowUserService
  def initialize(user_id)
    @user_id = user_id
  end

  def call
    User.find(@user_id)
  end
end
```

<div class="content-ad"></div>

UpdateUserService:

```js
# app/services/update_user_service.rb
class UpdateUserService
  def initialize(user, user_params)
    @user = user
    @user_params = user_params
  end

  def call
    if @user.update(@user_params)
      @user
    else
      @user.errors.full_messages
    end
  end
end
```

ForgotPasswordService:

```js
# app/services/forgot_password_service.rb
class ForgotPasswordService
  def initialize(email)
    @user = User.find_by(email: email)
  end

  def call
    if @user
      @user.send_reset_password_instructions
      "Reset password instructions sent."
    else
      "User not found."
    end
  end
end
```

<div class="content-ad"></div>

## 단계 5: 컨트롤러에서 서비스 객체 사용하기

새로운 서비스 객체를 사용하도록 컨트롤러를 업데이트하세요. UsersController에서 사용자를 표시하고 업데이트하는 방법은 다음과 같습니다:

```js
# app/controllers/users_controller.rb
class UsersController < ApplicationController
  def show
    service = ShowUserService.new(params[:id])
    user = service.call
    render json: user
  end

  def update
    service = UpdateUserService.new(current_user, user_params)
    result = service.call

    if result.is_a?(User)
      render json: result, status: :ok
    else
      render json: { errors: result }, status: :unprocessable_entity
    end
  end
end
```

비밀번호를 잊어버렸을 때의 기능을 위해 새로운 또는 기존 컨트롤러를 사용하세요.

<div class="content-ad"></div>


# app/controllers/passwords_controller.rb
class PasswordsController < ApplicationController
  def create
    service = ForgotPasswordService.new(params[:email])
    message = service.call
    render json: { message: message }
  end
end


## Step 6: Testing Service Objects

Service objects are great for testing because they encapsulate specific pieces of business logic. Here’s how you might test CreateUserService with RSpec:


# spec/services/create_user_service_spec.rb
require 'rails_helper'

RSpec.describe CreateUserService, type: :service do
  let(:user_params) { { name: 'John Doe', email: 'john@example.com', password: 'password', password_confirmation: 'password' } }

  context 'when valid parameters are provided' do
    it 'creates a new user' do
      service = CreateUserService.new(user_params)
      result = service.call

      expect(result).to be_a(User)
      expect(result).to be_persisted
    end
  end

  context 'when invalid parameters are provided' do
    it 'returns errors' do
      user_params[:email] = ''
      service = CreateUserService.new(user_params)
      result = service.call

      expect(result).to be_an(Array)
      expect(result).to include("Email can't be blank")
    end
  end
end


<div class="content-ad"></div>

## 서비스 객체 사용 최상의 방법

서비스 객체는 강력한 도구이지만, 최상의 방법을 따르는 것이 중요합니다. 여러분이 그들을 최대한 활용하기 위해서는 다음을 준수해야 합니다:

- 단일 책임 원칙: 각 서비스 객체가 한 가지 구체적인 작업을 처리하도록 보장하세요. 이렇게 하면 이해하기 쉽고 유지 보수 및 테스트가 용이해집니다.
- 명확한 명명: 서비스 객체를 명확하고 일관되게 명명하세요. CreateUserService, UpdateUserService 등과 같이 명확한 이름을 사용하세요.
- 오류 처리: 서비스 객체 내에서 오류를 적절히 처리하세요. 의미 있는 오류 메시지를 반환하여 컨트롤러가 사용자에게 적절한 피드백을 제공할 수 있도록 하세요.

테스트: 서비스 객체에 대해 포괄적인 테스트를 작성하여 예상대로 작동하는지 확인하세요. 엣지 케이스 및 오류 조건을 포함한 다양한 시나리오를 테스트하세요.

<div class="content-ad"></div>

# 결론

이 가이드를 따라가면 Rails 애플리케이션에서 서비스 객체를 만들고 사용하는 방법을 배우게 되어 코드를 더 깔끔하고 유지보수하기 쉽게 만들 수 있습니다. 서비스 객체는 컨트롤러와 모델이 주요 역할에 집중할 수 있도록 도와주며, 테스트 가능성을 향상시키고 가독성을 향상시킵니다.

즐거운 코딩 되세요!

Rails 앱에서 서비스 객체 만들어 활용하는 방법

학교 버스 추적 시스템 아키텍처 및 기능 설계 방법 정리



<img src="/assets/img/2024-08-26-ManagingHigh-TrafficApplicationswithAWSElasticLoadBalancerandTerraformAHands-OnLab_0.png" />

# 소개

이 블로그에서는 AWS Elastic Load Balancer (ELB)와 Terraform을 사용하여 확장 가능하고 고가용성 아키텍처를 만드는 방법을 안내합니다. VPC, 서브넷, 보안 그룹, EC2 인스턴스, ELB 및 Auto Scaling 그룹을 포함한 필요한 모든 것을 설정하고, Terraform 코드를 main.tf, variables.tf, outputs.tf 및 providers.tf로 구성합니다.

# 필수 조건

<div class="content-ad"></div>

- AWS 계정: 활성화된 AWS 계정이 필요합니다.
- Terraform 설치: 로컬 머신에 Terraform이 설치되어 있어야 합니다.
- 기본 지식: AWS 서비스(EC2, VPC, ELB)와 Terraform에 대한 기본 지식이 필요합니다.

# 프로젝트 구조

Terraform 코드에 들어가기 전에 프로젝트 디렉토리를 조직화해봅시다:

![프로젝트 구조](/assets/img/2024-08-26-ManagingHigh-TrafficApplicationswithAWSElasticLoadBalancerandTerraformAHands-OnLab_1.png)

<div class="content-ad"></div>

# 아키텍처 다이어그램

![Architecture Diagram](/assets/img/2024-08-26-ManagingHigh-TrafficApplicationswithAWSElasticLoadBalancerandTerraformAHands-OnLab_2.png)

# 프로젝트 단계

## 단계 1: Terraform 구성 설정하기

<div class="content-ad"></div>

## 1.1. 변수를 variables.tf에 정의하기

먼저, 우리가 테라폼 코드 전반에서 사용할 변수들을 정의해봅시다.

```js
#variables.tf


/*EC2 변수는 EC2 인스턴스의 AMI ID, 인스턴스 유형 및 VPC ID와 같은 값을 저장하는 데 사용할 수 있습니다. 
우리 테라폼 코드에서 이러한 값은 EC2 인스턴스를 생성하고 구성하는 데 사용됩니다. */

variable "ami" {
  description = "EC2 인스턴스의 AMI"
  type        = string
  default     = "ami-0715c1897453cabd1"
}

# 런치 템플릿 및 ASG 변수
variable "instance_type" {
  description = "런치 템플릿 EC2 인스턴스 유형"
  type        = string
  default     = "t2.micro"
}


#이 사용자 데이터 변수는 스크립트가 서버에 아파치를 구성한다는 것을 나타냅니다.
variable "ec2_user_data" {
  description = "스크립트가 서버에 아파치를 구성한다는 것을 나타냅니다"
  type        = string
  default     = <<EOF
#!/bin/bash
# 우분투에 아파치 설치
sudo apt update -y
sudo apt install -y apache2
sudo cat > /var/www/html/index.html << EOF
<html>
<head>
  <title> Apache 2023 Terraform </title>
</head>
<body>
  <p> Meriem의 AWS EC2 Auto-Scaling Group을 이용한 온라인 스토어에 오신 것을 환영합니다!
</body>
</html>
EOF
}


/*이 VPC는 인터넷이나 VPC 내 다른 리소스에서 액세스할 수 있어야 하는 리소스를 배포하는 데 사용할 수 있습니다.
이 변수는 VPC의 CIDR 블록을 정의합니다. 기본 값은 10.0.0.0/16입니다.
*/

# VPC 변수
variable "vpc_cidr" {
  description = "VPC CIDR 블록"
  type        = string
  default     = "10.10.0.0/16"
}

#이 Public 서브넷은 인터넷에서 액세스해야 하는 리소스에 사용됩니다.
variable "public_subnet_cidr" {
  description = "Public 서브넷 CIDR 블록"
  type        = list(string)
  default     = ["10.10.0.0/24", "10.10.2.0/24"]
}

#이 Private 서브넷은 인터넷에서 액세스할 필요가 없는 리소스를 배포하는 데 사용할 수 있습니다.
variable "private_subnet_cidr" {
  description = "Private 서브넷 CIDR 블록"
  type        = list(string)
  default     = ["10.10.3.0/24", "10.10.4.0/24"]
}

#이것은 환경 변수입니다
variable "environment" {
  description = "배포를 위한 환경 이름"
  type        = string
  default     = "terraformEnvironment"
}

# 이것은 지역 변수입니다
variable "aws_region" {
  description = "AWS 리전 이름"
  type        = string
  default     = "us-east-1"
}
```

<div class="content-ad"></div>

main.tf 파일에서 아키텍처에 필요한 모든 리소스를 정의할 것입니다.

```js
# main.tf

# Terraform Resources

# AWS에서 새 VPC 생성
resource "aws_vpc" "vpc" {
  cidr_block = var.vpc_cidr
  tags = {
    Name = "TerraformVPC2023"
  }
}

# AWS 가용 영역
data "aws_availability_zones" "available" {
  state = "available"
}

# 보안 그룹 리소스
resource "aws_security_group" "alb_security_group" {
  name        = "${var.environment}-alb-security-group"
  description = "ALB Security Group"
  vpc_id      = aws_vpc.vpc.id
  ingress {
    description = "인터넷에서의 HTTP 허용"
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
  tags = {
    Name = "${var.environment}-alb-security-group"
  }
}

...

# 패밀리 애로우 이미지 확인
data "aws_ami" "ubuntu" {
  most_recent = true
  filter {
    name   = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-*"]
  }
  filter {
    name   = "virtualization-type"
    values = ["hvm"]
  }
  owners = ["099720109477"]
}

# 시작 템플릿 및 ASG 리소스
resource "aws_launch_template" "launch_template" {
  name          = "${var.environment}-launch-template"
  image_id      = data.aws_ami.ubuntu.id
  instance_type = var.instance_type
  network_interfaces {
    device_index    = 0
    security_groups = [aws_security_group.asg_security_group.id]
  }
  tag_specifications {
    resource_type = "instance"
    tags = {
      Name = "${var.environment}-asg-ec2"
    }
  }
  user_data = base64encode("${var.ec2_user_data}")
}
```

## 1.3. outputs.tf에 출력값 정의

마지막으로, 로드 밸런서의 DNS 이름과 같은 중요한 값을 출력합니다.

<div class="content-ad"></div>

```js
#outputs.tf

# Terraform Outputs
output "alb_public_url" {
  description = "Application Load Balancer의 공개 URL"
  value       = aws_lb.alb.dns_name
}
```

## 1.4 providers.tf에서 프로바이더 정의

인프라 자원을 생성하고 관리하기 위해 Terraform이 사용할 클라우드 프로바이더를 지정합니다.

```js
#providers.tf

# Terraform Providers
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 4.0"
    }
  }
}
provider "aws" {
  region = "us-east-1"
}
```

<div class="content-ad"></div>

# 단계 2: 아키텍처 배포

이제 모든 테라폼 구성이 준비되었으니 아키텍처를 배포할 수 있습니다.

## 2.1. 테라폼 초기화

터미널에서 프로젝트 디렉토리로 이동하고 다음을 실행하세요:

<div class="content-ad"></div>

```js
terraform init
```

이 명령어는 Terraform 구성 파일이 포함된 작업 디렉토리를 초기화합니다.

## 2.2. 배포 계획 수립

다음 명령어를 실행하세요:

<div class="content-ad"></div>

```js
terraform plan
```

이 명령어를 실행하면 Terraform이 구성을 적용할 때 어떤 작업을 수행할지 보여줍니다.

## 2.3. 구성 적용

마지막으로, 인프라를 배포하기 위해 구성을 적용하세요:

<div class="content-ad"></div>

```js
terraform apply -auto-approve
```

# 단계 3: 애플리케이션 테스트

Terraform이 배포를 완료하면 로드 밸런서의 DNS 이름에 액세스하여 설정을 테스트할 수 있습니다:

```js
terraform output elb_dns_name
```

<div class="content-ad"></div>

DNS 이름을 복사하고 브라우저에서 열어보세요. 여기서 하나의 EC2 인스턴스에서 생성된 웹 페이지의 내용을 확인할 수 있어요. 이것으로 여러분의 로드 밸런서가 인스턴스 간 트래픽을 올바르게 분산하고 있는지 확인할 수 있습니다.

![이미지](/assets/img/2024-08-26-ManagingHigh-TrafficApplicationswithAWSElasticLoadBalancerandTerraformAHands-OnLab_3.png)

# 단계 4: 생성한 인프라를 제거하기

리소스를 제거하려면 터미널에서 다음 명령을 실행하세요. 여러분은 Terraform이 각 리소스의 상태를 새로 고친 다음 올바른 순서대로 제거하는 것을 확인할 수 있어요.

<div class="content-ad"></div>

```js
terraform destroy -auto-approve
```

![Image](/assets/img/2024-08-26-ManagingHigh-TrafficApplicationswithAWSElasticLoadBalancerandTerraformAHands-OnLab_4.png)

그리고 여기까지입니다!

# 사용된 자료:

<div class="content-ad"></div>

- [Terraform Up and Running](https://www.terraformupandrunning.com/)
- [Terraform Hands-On Labs on Udemy](https://www.udemy.com/course/terraform-hands-on-labs/)

If you want to access my notes and the flashcards I am building, you can find them [here](https://shadowed-bubble-139.notion.site/30-Day-Terraform-Challenge-dec28b59677845218d72dd4163751c87?pvs=4). I'll keep updating them as I progress through the challenge.

That’s all for today. Thank you for reading and following along! I hope this blog was helpful and worthwhile. Stay tuned for my next project in the cloud.

Let’s connect on [LinkedIn](https://www.linkedin.com/in/meriemterki/)! 👉

AWS Elastic Load Balancer와 Terraform를 활용한 고트래픽 애플리케이션 관리 방법



이 문서에서는 AWS EC2 인스턴스를 생성하고, Amazon Linux 머신에 Jenkins를 설치하기 위한 Ansible 플레이북을 작성할 것입니다.

Jenkins는 지속적 통합 및 지속적 배포(CI/CD) 파이프라인에 사용할 수 있는 강력한 자동화 서버입니다.

Ansible은 인프라의 프로비저닝과 구성을 자동화하는 데 사용되는 인기 있는 구성 관리 도구입니다.

필수 사항:
Ansible과 Jenkins의 기본 지식과 다음의 필수 사항이 있는지 확인해주세요:

<div class="content-ad"></div>

- AWS 계정
- Amazon Linux 인스턴스에 대한 EC2 인스턴스 연결 또는 SSH 액세스

# 단계 1: Amazon EC2 인스턴스 시작하기

EC2 인스턴스를 시작하려면:

- AWS Management Console에 로그인합니다.
- 계산 아래에서 EC2을 선택하여 Amazon EC2 콘솔을 엽니다.
- Amazon EC2 대시보드에서 '인스턴스 시작'을 선택합니다.

<div class="content-ad"></div>


![이미지](/assets/img/2024-08-26-SimplestepsindeployingJenkinsonAWSEC2usingAnsible_0.png)

4. Choose an OS Images Amazon Machine Image (AMI) Free tier eligible Amazon Linux 2023 AMI

![이미지](/assets/img/2024-08-26-SimplestepsindeployingJenkinsonAWSEC2usingAnsible_1.png)

5. Scroll down and create a new key pair for SSH connection. For simplicity and quick access, we will use EC2 Instance connect.


<div class="content-ad"></div>

6. 새 보안 그룹을 만들고 다음 규칙을 추가하세요:

- 어디서나 들어오는 HTTP 액세스를 허용합니다.
- 내 컴퓨터의 공개 IP 주소에서 들어오는 SSH 트래픽을 허용하여 인스턴스에 연결할 수 있도록 합니다.
- 포트 범위에 8080을 입력합니다.

7. 인스턴스 시작을 선택하세요.

![이미지](/assets/img/2024-08-26-SimplestepsindeployingJenkinsonAWSEC2usingAnsible_2.png)

<div class="content-ad"></div>

8. 왼쪽 네비게이션 바에서 '인스턴스'를 선택하여 인스턴스의 상태를 확인하세요. 처음에는 인스턴스 상태가 대기 중인 'pending' 상태일 것입니다. 상태가 'running'으로 변경되면 인스턴스를 사용할 준비가 된 것입니다.

![인스턴스 상태 이미지](/assets/img/2024-08-26-SimplestepsindeployingJenkinsonAWSEC2usingAnsible_3.png)

9. Linux 인스턴스에 연결하기

- EC2 인스턴스 연결을 사용하여 연결하세요.

<div class="content-ad"></div>


![Step 2](/assets/img/2024-08-26-SimplestepsindeployingJenkinsonAWSEC2usingAnsible_4.png)

![Step 3](/assets/img/2024-08-26-SimplestepsindeployingJenkinsonAWSEC2usingAnsible_5.png)

![Step 4](/assets/img/2024-08-26-SimplestepsindeployingJenkinsonAWSEC2usingAnsible_6.png)

# Step 2: Install Ansible


<div class="content-ad"></div>

- EC2 인스턴스에 연결하고, root 사용자로 전환하여 ansible을 설치해 보세요:

```js
sudo -i
sudo yum update && yum install ansible
```  

![이미지](/assets/img/2024-08-26-SimplestepsindeployingJenkinsonAWSEC2usingAnsible_7.png)

2. Ansible 버전 확인하기

<div class="content-ad"></div>

```js
앤서블 --버전
```

<img src="/assets/img/2024-08-26-SimplestepsindeployingJenkinsonAWSEC2usingAnsible_8.png" />

3. 앤서블 플레이북을 사용하여 젠킨스를 설치할 것입니다.

- 앤서블 플레이북 yaml 파일을 생성할 것입니다: setup_jenkins.yaml

<div class="content-ad"></div>

```yaml
cat > setup_jenkins.yml << EOF 
---
- hosts: localhost
  connection: local
  vars:
    java_packages:
      - java-17-amazon-corretto-devel
    jenkins_packages:
      - jenkins  
  tasks:
    - name: Download Jenkins repository file
      get_url:
        url: https://pkg.jenkins.io/redhat-stable/jenkins.repo
        dest: /etc/yum.repos.d/jenkins.repo
      become: true

    - name: Import Jenkins-CI key
      shell: rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io-2023.key
      become: true

    - name: Install Java
      yum:
        name: "{ java_packages }"
        state: present
      become: true

    - name: Install jenkins
      yum:
        name: "{ jenkins_packages }"
        state: present
      become: true

    - name: Start jenkins service
      service:
        name: jenkins
        state: started
      become: true
EOF
```

4. 그런 다음 실행하십시오:

```js
ansible-playbook setup_jenkins.yml
```

5. 성공하면 아래 출력을 확인할 수 있어야 합니다.

<div class="content-ad"></div>


![이미지](/assets/img/2024-08-26-SimplestepsindeployingJenkinsonAWSEC2usingAnsible_9.png)

6. 이제 브라우저에서 공용 IPv4 주소를 사용하여 포트 8080으로 이동합니다.

예시: http://3.6.86.139:8080/

![이미지](/assets/img/2024-08-26-SimplestepsindeployingJenkinsonAWSEC2usingAnsible_10.png)


<div class="content-ad"></div>

7. 브라우저에서 Jenkins가 시작되었을 때, 아래와 같이 패스워드를 찾을 수 있습니다:

![Jenkins Password](/assets/img/2024-08-26-SimplestepsindeployingJenkinsonAWSEC2usingAnsible_11.png)

8. 패스워드를 얻으려면:

```bash
cat /var/lib/jenkins/secrets/initialAdminPassword
```

<div class="content-ad"></div>

9. Jenkins 잠금 해제: 화면 안내에 따라 Jenkins를 잠금 해제하고 초기 설정을 완료하세요.

10. Jenkins 구성: 필요에 따라 Jenkins 설정을 사용자 정의하고 플러그인을 설치하여 요구 사항에 맞게 설정하세요.

![이미지](/assets/img/2024-08-26-SimplestepsindeployingJenkinsonAWSEC2usingAnsible_12.png)

이 프로젝트가 마음에 드셨으면 좋겣습니다. 좋아요를 남겨주시고 다음 프로젝트에서 만나요!