as cool as snowman

[leetcode] 689. Maximum Sum of 3 Non-Overlapping Subarrays

jongyun ha — Sat, 28 Dec 2024 12:52:59 +0900

https://leetcode.com/problems/maximum-sum-of-3-non-overlapping-subarrays/description/

해당 문제는 정수배열 nums 와 k 가 주어졌을 때 겹치지 않는 최대합을 가지는 길이 k 의 부분 배열 3개를 찾아서 반환하는 문제입니다

여기서 주의할 점은 정답이 여러개 인 경우 index 가 작은것 부터 반환해야 합니다.

Approach

해당 문제는 총 3개의 부분 배열을 반환해야 합니다 그러므로 3 개의 section 으로 분할 할 수 있고 이것을 left, middle, right 라고 정의 하겠습니다.

먼저 sliding window 를 통해 구간 합을 미리 구해 두겠습니다.

val sums = IntArray(n) { i ->
    nums.slice(i until i + k).sum()
}

그런 다음 왼쪽에서 시작했을때의 최대값을 계산합니다.

val left = IntArray(n)
var maxIndex = 0
for (i in 0 until n) {
    if (sums[i] > sums[maxIndex]) {
        maxIndex = i
    }
    left[i] = maxIndex
}

마찬 가지로 오른쪽에서 시작했을때의 최대값을 계산합니다.

val right = IntArray(n)
maxIndex = n - 1
for (i in n - 1 downTo 0) {
    if (sums[i] >= sums[maxIndex]) {
        maxIndex = i
    }
    right[i] = maxIndex
}

마지막으로 합이 가장 큰 최적의 조합을 찾습니다.

for (i in k until n - k) {
    val leftIndex = left[i - k]
    val rightIndex = right[i + k]
    val totalSum = sums[leftIndex] + sums[i] + sums[rightIndex]
    
    if (totalSum > maxSum) {
        maxSum = totalSum
        result[0] = leftIndex
        result[1] = i
        result[2] = rightIndex
    }
}

시간 복잡도: O(n)
- 구간합 계산: O(n)
- 왼쪽/오른쪽 최대값 계산: 각각 O(n)
- 최적 조합 찾기: O(n)
공간 복잡도: O(n)
- sums, left, right 배열: 각각 O(n)

전체 코드

class Solution {
    fun maxSumOfThreeSubarrays(nums: IntArray, k: Int): IntArray {
        val n = nums.size - k + 1

        val sums = IntArray(n) { i ->
            nums.slice(i until i + k).sum()
        }

        val left = IntArray(n)
        var maxIndex = 0

        for (i in sums.indices) {
            if (sums[i] > sums[maxIndex]) {
                maxIndex = i
            }
            left[i] = maxIndex
        }

        val right = IntArray(n)
        maxIndex = n - 1

        for (i in n - 1 downTo 0) {
            if (sums[i] >= sums[maxIndex]) {
                maxIndex = i
            }
            right[i] = maxIndex
        }

        val result = IntArray(3)
        var maxSum = Int.MIN_VALUE

        for (i in k until sums.size - k) {
            val leftIdx = left[i - k]
            val rightIdx = right[i + k]
            val sum = sums[leftIdx] + sums[i] + sums[rightIdx]
            if (sum > maxSum) {
                maxSum = sum
                result[0] = leftIdx
                result[1] = i
                result[2] = rightIdx
            }
        }

        return result
    }
}

leetcode - 862. Shortest Subarray with Sum at Least K

jongyun ha — Sun, 17 Nov 2024 15:47:31 +0900

https://leetcode.com/problems/shortest-subarray-with-sum-at-least-k/description/?envType=daily-question&envId=2024-11-17

Approach

해당 문제를 O(N) 시간 복잡도로 문제를 해결 하기 위해서 PrefixSum 과 단조 증가 (Monotonic increasing) Queue 를 사용할 예정입니다.

해당 문제를 한글로 번역해보자면 다음과 같습니다.

정수 배열 nums와 정수 k가 주어졌을 때, 다음 조건을 만족하는 가장 짧은 부분 배열의 길이를 반환하세요:

부분 배열의 합이 최소한 k 이상이어야 함
부분 배열은 비어있지 않아야 함
만약 이러한 조건을 만족하는 부분 배열이 존재하지 않는다면 -1을 반환

여기서 **부분 배열(subarray)**은 원래 배열의 연속된 부분을 의미합니다.

예를 들어 설명하자면:

[1,2,3] 배열에서 [2,3]은 유효한 부분 배열입니다 (연속된 요소들)
[1,3]은 유효한 부분 배열이 아닙니다 (2를 건너뛰었기 때문에 연속적이지 않음)

초기설정

n := len(nums)
result := math.MaxInt
deque := make([]int, 0)

n: 배열의 길이
result: 최소 길이를 저장할 변수 (초기값은 최대정수)
deque: 단조증가하는 prefix sum의 인덱스를 저장할 덱(양방향 큐)

누적합(Prefix Sum) 계산

prefixSum := make([]int, n+1)
for i := 0; i < len(prefixSum)-1; i++ {
   prefixSum[i+1] = prefixSum[i] + nums[i]
}

prefixSum[i]: 0부터 i-1까지의 누적합
예: nums = [2,-1,2]일 때
prefixSum = [0,2,1,3]

메인 로직

for i := 0; i < len(nums); i++ {
   // 첫 번째 while 루프
   for len(deque) > 0 && prefixSum[i]-prefixSum[deque[0]] >= k {
      result = min(result, i-deque[0])
      deque = deque[1:]
   }

   // 두 번째 while 루프
   for len(deque) > 0 && prefixSum[i] <= prefixSum[deque[len(deque)-1]] {
      deque = deque[:len(deque)-1]
   }
   deque = append(deque, i)
}

첫 번째 루프: 현재까지의 누적합에서 덱의 첫 번째 원소(가장 오래된 인덱스)를 뺀 값이 k 이상이면
- 가능한 부분배열을 찾은 것이므로 길이를 업데이트
- 더 짧은 부분배열을 찾기 위해 덱의 첫 번째 원소를 제거
두 번째 루프: 단조성 유지를 위한 처리
- 현재 누적합보다 큰 이전 누적합들은 제거
- 이렇게 함으로써 덱은 단조증가하는 형태 유지

이 부분은 덱(deque)의 단조성을 유지하기 위한 핵심적인 조건입니다.

len(deque) > 0 && prefixSum[i] <= prefixSum[deque[len(deque)-1]]

len(deque) > 0: 덱이 비어있지 않은지 확인
prefixSum[i]: 현재 보고 있는 위치까지의 누적합
deque[len(deque)-1]: 덱의 마지막 원소 (가장 최근에 추가된 인덱스)
prefixSum[deque[len(deque)-1]]: 덱의 마지막 위치의 누적합

왜 이 조건이 필요한가?

현재 덱 상태: [0, 2, 4]
prefixSum[0] = 0
prefixSum[2] = 4
prefixSum[4] = 2

만약 현재 누적합이 덱의 마지막 원소의 누적합보다 작거나 같다면
덱의 마지막 원소는 더 이상 최소 부분배열의 후보가 될 수 없음
왜냐하면:
1. 더 뒤에 있는 위치(더 긴 부분배열)
2. 더 큰 누적합을 가짐
3. 따라서 최소 길이를 찾는데 도움이 되지 않음

leetcode: Maximum Sum Circular Subarray (kadane 알고리즘)

jongyun ha — Sun, 10 Nov 2024 22:27:14 +0900

https://leetcode.com/problems/maximum-sum-circular-subarray/

해당 문제는 kadane 알고리즘 방법으로 접근하여 문제를 해결 하였습니다.

Approach

Kadane's algorithm을 사용하여 일반적인 최대 부분합을 O(n)에 구합니다.
순환하는 경우는 전체 합에서 최소 부분합을 빼서 구합니다.
모든 원소가 음수인 경우는 별도로 처리합니다.

시간복잡도: O(n) 공간복잡도: O(1)

전체 배열의 합 (total): 5 + (-3) + 5 = 7
최소 부분합 (minSum): -3
- 연속된 부분 배열 중 가장 작은 합
total - minSum = 7 - (-3) = 10
- 이것이 바로 [5,5]를 선택했을 때의 합과 같습니다!

이렇게 되는 이유는:

순환 배열에서 양 끝의 원소들을 선택하려면 (예: [5,5])
중간에 있는 원소들을 제외해야 합니다 (예: [-3])
중간의 원소들을 제외하는 가장 좋은 방법은 "최소 부분합"을 찾아서 제거하는 것입니다
따라서 "전체 합 - 최소 부분합"이 순환 배열에서 가능한 최대 부분합이 됩니다

이 방식은 다음과 같은 장점이 있습니다:

한 번의 순회로 최소 부분합을 찾을 수 있습니다 (O(n))
전체 합도 한 번의 순회로 구할 수 있습니다 (O(n))
추가 메모리를 사용하지 않습니다 (O(1))

func maxSubarraySumCircular(nums []int) int {
	if len(nums) == 0 {
		return 0
	}

	kadane := func(nums []int, findMax bool) int {
		curr := nums[0]
		result := nums[0]

		for i := 1; i < len(nums); i++ {
			if findMax {
				curr = max(nums[i], curr+nums[i])
				result = max(curr, result)
			} else {
				curr = min(nums[i], curr+nums[i])
				result = min(curr, result)
			}
		}
		return result
	}

	findMax := kadane(nums, true)
	if findMax < 0 {
		return findMax
	}

	totalSum := 0

	for _, num := range nums {
		totalSum += num
	}

	findMin := kadane(nums, false)
	return max(findMax, totalSum-findMin)
}

Docker 리소스 제약 (Resource constraints) 에 대하여

jongyun ha — Fri, 25 Oct 2024 22:01:28 +0900

기본적으로 container resource 는 제약이 없으며 호스트의 커널 스케줄러가 허용하는 한계치 까지 주어진 리소스를 최대한 사용할 수 있습니다.

하나의 machine (Ubuntu) 이 cpu 4 core / memory 8GB 라고 가정했을때 4개의 application 을 실행하고

2개의 application 에 메모리 누수가 있다고 가정했을때 2개 의 application 모두 8GB 까지 메모리를 사용하려고 합니다
해당 상황은 해당 Ubuntu machine 을 shutdown 시키는 결과를 초래 할 수 있고 운영 상황에서는 큰 장애로 이어 질 수 있습니다.

그럼 해당 이슈를 어떻게 우아하게 처리 할 수 있는지 알아 보겠습니다

이 글은 Docker 공식문서를 참고했습니다.

https://docs.docker.com/engine/containers/resource_constraints/

Resource constraints

Specify the runtime options for a container

docs.docker.com

메모리 제한 (Memory limit)

Docker 는 메모리 제한을 두가지로 제한 할 수 있습니다. 하나는 소프트 이고 하나는 하드입니다.

하드: hard 를 사용하면 컨테이너가 고정된 양의 메모리만 사용할 수 있습니다.

소프트: soft 를 사용하면 커널이 메모리 부족이나 host 머신에서 경합을 감지하는등 특정 조건이 충족되지 않는 한 컨테이너가 필요한 만큼의 메모리를 사용할 수 있습니다.

여기서 중요한 옵션은 memory 와 reservation 입니다.

대중적으로 사용하길 reservation 의 2배를 memory 로 설정합니다

memory 와 reservation 의 수치는 magic number 이므로 배포할 application 에 대해 모니터링 한뒤 세부조정을 하시는것을 추천 드립니다.

CPU 제한

기본적으로 각 컨테이너의 호스트 머신 CPU 사이클에 대한 액세스는 무제한 입니다.

CPU가 1개 있는 경우 다음 명령은 각각 1초마다 컨테이너가 최대 CPU의 50%를 사용하도록 보장합니다.

 docker run -it --cpus=".5" ubuntu /bin/bash

주의해야할점

CPU 스케줄링 및 우선순위 지정은 고급 커널 수준 기능입니다. 대부분 사용자는 이러한 값을 기본값에서 변경할 필요가 없습니다. 이러한 값을 잘못 설정하면 호스트 시스템이 불안정해지거나 사용할 수 없게 될 수 있습니다.

마지막으로 전체적인 예제입니다.

api:
  image: node:16-alpine
  container_name: backend-api
  deploy:
    resources:
      limits:
        cpus: '1'
        memory: 1G
      reservations:
        cpus: '0.5'
        memory: 512M
  environment:
    - NODE_ENV=production
    - MAX_OLD_SPACE_SIZE=768
  volumes:
    - type: volume
      source: api-storage
      target: /app/storage
      volume:
        nocopy: true
        size: 2G
  healthcheck:
    test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:3000/health"]
    interval: 30s
    timeout: 10s
    retries: 3

Leetcode - Gas Station

jongyun ha — Sat, 2 Mar 2024 16:57:39 +0900

Problem

There are n gas stations along a circular route, where the amount of gas at the ith station is gas[i].

You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from the ith station to its next (i + 1)th station. You begin the journey with an empty tank at one of the gas stations.

Given two integer arrays gas and cost, return the starting gas station's index if you can travel around the circuit once in the clockwise direction, otherwise return -1. If there exists a solution, it is guaranteed to be unique

Example 1:

Input: gas = [1,2,3,4,5], cost = [3,4,5,1,2]
Output: 3
Explanation:
Start at station 3 (index 3) and fill up with 4 unit of gas. Your tank = 0 + 4 = 4
Travel to station 4. Your tank = 4 - 1 + 5 = 8
Travel to station 0. Your tank = 8 - 2 + 1 = 7
Travel to station 1. Your tank = 7 - 3 + 2 = 6
Travel to station 2. Your tank = 6 - 4 + 3 = 5
Travel to station 3. The cost is 5. Your gas is just enough to travel back to station 3.
Therefore, return 3 as the starting index.

Example 2:

Input: gas = [2,3,4], cost = [3,4,3]
Output: -1
Explanation:
You can't start at station 0 or 1, as there is not enough gas to travel to the next station.
Let's start at station 2 and fill up with 4 unit of gas. Your tank = 0 + 4 = 4
Travel to station 0. Your tank = 4 - 3 + 2 = 3
Travel to station 1. Your tank = 3 - 3 + 3 = 3
You cannot travel back to station 2, as it requires 4 unit of gas but you only have 3.
Therefore, you can't travel around the circuit once no matter where you start.

Approach

주어진 문제는 시계방향으로 주유소를 돌면서 다시 제자리로 돌아올 수 있는지 확인하는 문제다.

다시 제자리로 돌아오면서 연료 탱크의 값이 한번이라도 음수가 되면 -1 을 리턴하면 된다.

이문제의 접근법으로 그리디를 선택했는데 선택한 이유는 다음과 같다.

로컬 최적 해가 글로벌 최적 해로 이어짐: 문제의 구조상, 어떤 주유소에서 출발해 연료가 바닥나기 전에 다음 주유소에 도달할 수 있다면, 그 선택은 최적의 로컬 해이다. 이러한 로컬 최적의 선택들이 연속적으로 이어질 때 전체 경로를 완주할 수 있는 글로벌 최적 해를 구성한다.
연료의 누적 및 소비 패턴: 주유소에서 연료를 충전하고 다음 주유소로 이동하는 과정에서 연료의 누적과 소비가 일어난다. 그리디 알고리즘을 사용하면 각 단계에서 연료의 누적량과 소비량을 계산하여 현재 상태에서 가장 좋은 결정(다음 주유소로 이동할 수 있는지 여부)을 즉각적으로 내릴 수 있다.
유일한 해의 존재: 문제에서는 해가 존재한다면 그 해가 유일하다고 명시되어 있다. 그리디 알고리즘을 사용하여 한 번의 순회로 출발 가능한 주유소를 찾아낼 수 있으며, 이는 문제의 조건과 일치한다.
효율성: 모든 주유소를 순회하면서 현재 연료량과 각 주유소에서의 연료 충전량, 그리고 다음 주유소로의 이동 비용을 고려하여 그리디 알고리즘을 적용하면, O(n)의 시간 복잡도로 문제를 해결할 수 있다. 이는 대규모 데이터셋에도 효과적으로 작동하는 효율적인 접근 방식이다.

func canCompleteCircuit(gas []int, cost []int) int {
	totalGas, totalCost, start, tank := 0, 0, 0, 0

	for i := 0; i < len(gas); i++ {
		currGas := gas[i]
		currCost := cost[i]

		totalGas += currGas
		totalCost += currCost
		tank += currGas - currCost
		if tank < 0 {
			start = i + 1
			tank = 0
		}
	}

	if totalCost > totalGas {
		return -1
	}

	return start
}

마지막에 totalCost 와 totalGas 를 비교하는 부분에 대해서 설명하자면 totalCost 가 totalGas 보다 큰경우 어떠한 주유소에서 시작해도 다시 제자리로 돌아올수 없기 때문에 start 값이 유효하지 않다.

그러므로 -1 을 리턴한다.

Leetcode86. partition list (kotlin)

jongyun ha — Sat, 22 Apr 2023 19:18:17 +0900

https://leetcode.com/problems/partition-list/

Partition List - LeetCode

Can you solve this real interview question? Partition List - Given the head of a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x. You should preserve the original relative order of the no

leetcode.com

Given the head of a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each of the two partitions.

Example 1:

Input: head = [1,4,3,2,5,2], x = 3
Output: [1,2,2,4,3,5]

Approach

해당 문제는 주어진 x 보다 작은 것들은 왼쪽 더 큰것들은 오른쪽으로 정렬 하는 문제입니다.

여기서 주의해야 할점은 기존의 순서를 그대로 유지해야 합니다.

x 보다 작은것들을 연결할 Listnode(lessNode) 를 만들고 x 보다 큰 것들을 연결할 LIstnode(moreNode) 를 만듭니다.
head 를 iteration 하면서 x 보다 작으면 lessNode 의 next 로 Listnode(val) 을 추가하고 크다면 moreNode 의 next 로 Listnode(val) 을 추가합니다.

fun partition(head: ListNode, x: Int): ListNode? {
    val lessHead = ListNode(-1)
    val moreHead = ListNode(-1)
    var less = lessHead
    var more = moreHead
    var node: ListNode? = head
    while (node != null) {
        if (node.`val` < x) {
            less.next = ListNode(node.`val`)
            less = less.next!!
        } else {
            more.next = ListNode(node.`val`)
            more = more.next!!
        }
        node = node.next
    }

    less.next = moreHead.next

    return lessHead.next
}

Leetcode79. Word Search (w. kotlin)

jongyun ha — Sun, 16 Apr 2023 14:55:17 +0900

Given an m x n grid of characters board and a string word, return true if word exists in the grid.

The word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once.

Example 1:

val board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]]
val word = "SEE"

Output: true

Approach

해당 문제는 Backtracking 을 사용하여 상하좌우 의 문자열을 이어 나가면서 기대하는 Word 와 일치 하는지 에 대한 결과를 구하는 문제입니다.

word = "SEE" 중 S 가 위치한 (row, col) 값을 찾습니다.
(1, 0) 에 위치한 S 의 상하좌우 를 DFS 로 탐색합니다. 방문한 곳은 board 에 "*" 로 마킹합니다.
LEFT (index 를 벗어남) , RIGHT(F 유효하지않음), UP(A 유효하지 않음), DOWN(A 유효하지 않음) 상하좌우 모두 유효하지 않기 때문에 넘어갑니다.
"*" 로 마킹 한 곳은 다시 문자열을 채워줍니다.
(1, 3) 에 위치한 S 를 상하좌우 를 DFS 로 탐색합니다. DOWN 에 위치한 (E) 가 유효 하고 E 로 DFS 탐색을 했을시 LEFT 가 유효하여 true 가 retrun 됩니다.

fun exist(board: Array<CharArray>, word: String): Boolean {
    if (board.isEmpty()) return false
    if (word.isBlank()) return true

    val checker = Array(board.size) { BooleanArray(board.first().size) }
    for (i in board.indices) {
        for (j in board[i].indices) {
            if (helper(board, checker, word, i, j, 0)) {
                return true
            }
        }
    }
    return false
}

fun helper(
    board: Array<CharArray>,
    checker: Array<BooleanArray>,
    word: String,
    row: Int,
    col: Int,
    start: Int
): Boolean {
    if (start == word.length) return true
    if (!isValid(row, col, board) || board[row][col] != word[start]) return false

    board[row][col] = '*'
    val result = helper(board, checker, word, row + 1, col, start + 1) ||
            helper(board, checker, word, row - 1, col, start + 1) ||
            helper(board, checker, word, row, col + 1, start + 1) ||
            helper(board, checker, word, row, col - 1, start + 1)
    board[row][col] = word[start]
    return result
}

fun isValid(row: Int, col: Int, board: Array<CharArray>): Boolean {
    return row in (board.indices) && col in (board.first().indices)
}

fun main() {
    val board = arrayOf(
        charArrayOf('A', 'B', 'C', 'E'),
        charArrayOf('S', 'F', 'C', 'S'),
        charArrayOf('A', 'D', 'E', 'E'),
    )
    val word = "ABCCED"
    exist(board, word).also { println(it) }
}

Kubenetes 배포시 5xx 이슈에 대한 해결책

jongyun ha — Fri, 24 Mar 2023 22:54:06 +0900

쿠버네티스를 사용하여 어플리케이션을 배포 할때 5xx 에러를 만날때가 있다. 제일 처음으로 확인해볼건 probe 설정이다.

livenessProbe

컨테이너가 동작 중인지 여부를 나타낸다. 만약 활성 프로브(liveness probe)에 실패한다면, kubelet은 컨테이너를 죽이고,
해당 컨테이너는 재시작 정책 의 대상이 된다.

만약 컨테이너가 활성 프로브를 제공하지 않는 경우, 기본 상태는 Success 이다.

readnessProbe

컨테이너가 요청을 처리할 준비가 되었는지 여부를 나타낸다. 만약 준비성 프로브(readiness probe)가 실패한다면, 엔드포인트 컨트롤러는 파드에 연관된 모든 서비스들의 엔드포인트에서 파드의 IP주소를 제거한다. 준비성 프로브의 초기 지연 이전의 기본 상태는 Failure이다.

만약 컨테이너가 준비성 프로브를 지원하지 않는다면, 기본 상태는 Success이다.

startupProbe

서비스를 시작하는 데 오랜 시간이 걸리거나 불규칙적인 컨테이너에 설정하는 데 사용될 수 있다.(예를 들면 third party 에서 특정 데이터를 다운받는 등의 경우) startup probe가 성공하고 나서 liveness, readiness probe가 동작하기 때문에 기동시간이 불규칙적인 애플리케이션이 liveness probe에 의해 기동되기도 전에 재시작 되는 것을 방지할 수 있다.(Readiness probe랑 비슷하지만 방금 말한 부분은 Readiness probe로 해결하기 어렵다)

livenessProbe 와 readnessProbe 의 차이점

컨테이너의 상태 체크중에 livenessProbe 의 경우에는 컨테이너가 비정상적으로 작동이 불가능한 경우도 있지만,

Configuration을 로딩하거나, 많은 데이타를 로딩하거나, 외부 서비스를 호출하는 경우에는 일시적으로 서비스가 불가능한 상태가 될 수 있다

이런 경우에는 컨테이너를 재시작한다 하더라도 정상적으로 서비스가 불가능할 수 있다.

이런 경우에는 컨테이너를 일시적으로 서비스가 불가능한 상태로 마킹해주면 되는데, 이러한 기능을 readnessProbe 가 담당한다.

https://bcho.tistory.com/1264

쿠버네티스 #9 - HealthCheck

쿠버네티스 #9Health Check 조대협 (http://bcho.tistory.com) 쿠버네티스는 각 컨테이너의 상태를 주기적으로 체크해서, 문제가 있는 컨테이너를 자동으로 재시작하거나 또는 문제가 있는 컨테이너(Pod를)

bcho.tistory.com

정상적으로 Probe 를 구성했음에도 배포시 5xx 에러가 발생할때

pod 가 생성될때 5xx 에러가 발생한다면 probe 설정이 잘못된건 없는지 확인한다.

AWS ALB(ingress) 를 사용하고 있다면 배포 과정에서 pod 와의 연결이 정상적으로 끊기지 전달 되었거나 또는 신규 Pod 들의 Ready 상태가 반영 되지않고 ALB Target group 에 대상이 등록된 경우가 많다.

이를 개선하기 위해선 preStop 실행 과정에서 sleep 을 사용하여 pod 의 애플리케이션이 정상적으로 기존연결을 끊는지 확인이 필요하다.

그리고 Pod 의 readniess 상태를 AWS Loadbalancer Controller 에서 TargetGroup 에 Pod IP 들을 등록하는 과정에서 Readniess probe 상태를 반영하며 작동할 수 있게 하는 Readniess gate 설정도 반드시 필요하다.

https://kubernetes-sigs.github.io/aws-load-balancer-controller/v2.1/deploy/pod_readiness_gate/

Pod Readiness Gate - AWS LoadBalancer Controller

Pod readiness gate AWS Load Balancer controller supports »Pod readiness gates« to indicate that pod is registered to the ALB/NLB and healthy to receive traffic. The controller automatically injects the necessary readiness gate configuration to the pod sp

kubernetes-sigs.github.io

다음으로 살펴볼건 Pod 의 application 의 keep alive 설정이 ALB 의 IDLE Timeout 보다 짧게 설정된건 아닌지 확인해볼것

spring boot jib 를 사용 하여 배포 자동화 하기 (w. github action)

jongyun ha — Thu, 23 Mar 2023 18:46:13 +0900

jib 란?

Jib는 Dockerfile을 사용하지 않거나 Docker를 설치할 필요 없이 컨테이너를 빌드할 수 있도록 도와주는 도구이다.

특히 자바 컨테이너를 빌드하는 데 사용하는 도구이며, Maven과 Gradle 용 플러그인을 이용해 사용할 수도 있고 Jib 자바 라이브러리를 통해 사용할 수도 있다.

적용해보기

build.gradle.kts

plugin {
...
	id("com.google.cloud.tools.jib") version "3.1.2" apply false
...
}

버전은 해당 spring boot, kotlin, java 버전에 맞게 설정 이 필요하다.

val stage: String? by project // github action 에서 -Pstage=alpha 옵션으로 주입
val imageTag: String? by project // github action 에서 -PimageTag=AA-BB 옵션으로 주입

jib {
	from {} // 애플리케이션을 빌드할 기본 이미지를 구성
	to {} // 애플리케이션을 빌드할 대상 이미지를 구성
	extraDirectories {} // 이미지에 임의의 파일을 추가하는 데 사용되는 디렉토리를 구성
	container {} // 빌드된 이미지에서 실행되는 컨테이너를 구성
	mainClass = ""
	user = ""
	ports = "" // Dockerfile 의 EXPOSE 와 유사
	creationTime = "" // 컨테이너 생성 시간을 설정
}

github action 에서 환경과 imageTag 이름을 주입하기 위해 따로 변수를 생성한다.

github action

- name: Build tag, and push image with jib
  id: build-image
  run: |
    ./gradlew -PcontainerImage=${{ env.DOCKER_REPOSITORY }} -PimageTag=${{ env.IMAGE_TAG }} -Pstage=${{ env.PHASE }} jib --no-daemon

테스트 환경에서는 ECR 을 사용하여 docker image 를 관리하고 jib 에 다음과 같이 설정했다.

credHelper = "ecr-login"

jvm custom option

container {
    jvmFlags = when (stage) {
        "dev" -> listOf("-Xms4g", "-Xmx4g")
        "prod" -> listOf("-Xms8g", "-Xmx8g")
        else -> emptyList()
    }

    environment = mapOf("port" to 8080)
    mainClass = mainClassPath
    user = "user"
    ports = listOf(8080)
    creationTime = containerCreationTime
}

이런 식으로 튜닝도 가능하다.

체감상 docker build 에서 jib 로 바꾼뒤 캐시가 적중했을때 1분 가까이 차이가 나기도 한다.

CloudFront 와 Browser cache

jongyun ha — Sat, 26 Nov 2022 19:58:08 +0900

Cloud front 란?

https://docs.aws.amazon.com/ko_kr/AmazonCloudFront/latest/DeveloperGuide/Introduction.html

Amazon CloudFront란 무엇입니까? - Amazon CloudFront

Amazon CloudFront란 무엇입니까? Amazon CloudFront는 .html, .css, .js 및 이미지 파일과 같은 정적 및 동적 웹 콘텐츠를 사용자에게 더 빨리 배포하도록 지원하는 웹 서비스입니다. CloudFront는 엣지 로케이션

docs.aws.amazon.com

cloud front 설정의 cache 의 TTL 을 설정할때 min, max default 값이 있따는 것은 Origin (s3) 에서 보낸 Metadata 의 Cache-Control 값을 존중해서 사용한다는 뜻입니다.

cloud front 의 Min 보다 작은 값을 Origin 에서 보내오면 min 값을 TTL 값으로 사용하겠다는 뜻이며, cloud front 의 max 값 보다 큰 값을 Origin 에서 보내오면 max 값을 TTL 값으로 사용한다는 뜻입니다.

또한, Origin 에서 특정한 Cache-Control 값이 없으면 Default 값을 사용한다는 뜻입니다.

TTL 이 긴데도 불구하고 Cache Miss 가 나는 경우

처음 요청하는 Object 인 경우
해당 Region 의 edge 서버 들에 부하가 있어 다른 region 으로 라우팅 되었을 경우
- cache 는 region 별로 달리 저장되기 때문에 다른 region 으로 라우팅 되면 miss 가 발생 할 수 있음

동작방식

cloud front 의 설정은 origin server 의 데이터를 캐싱하는 설정이고 client 에서 ttl 시간 내에 반복적으로 보내온 요청을 origin server 에 물어보지 않고 바로 cloud front 가 처리함

web browser 가 캐싱 했다가 cf 에 다시 요청해야 하는 기간 TTL 이 만료되고 브라우저에서 CF 로 요청 CF 에 캐싱이 없으면

origin server 로 요청 customize 로 설정되어 있는 경우 origin server 의 cache control 을 최대한 존중

Use origin cache headers 일 경우 cache-control 을 그대로 사용

Status code [200, 304]

200 - hit from cloud front

304 - hit from cloud front

https://docs.aws.amazon.com/ko_kr/AmazonCloudFront/latest/DeveloperGuide/Expiration.html#ExpirationDownloadDist

콘텐츠가 캐시에 유지되는 기간(만료) 관리 - Amazon CloudFront

CloudFront가 Cache-Control: no-cache, no-store 및/또는 private 지시문이 포함된 오리진에서 객체를 가져온 다음 나중에 동일한 객체에 대한 다른 최종 사용자 요청을 가져오는 경우 CloudFront는 오리진에 연

docs.aws.amazon.com

AWS 문서에 따르면 cache-control 이 없으면 browser 에 대한 cache 는 browser 마다 각각 다르다.

CF 설정은 TTL 은 cloud front 단에서 관리하는 캐시 설정이므로 browser 에서 캐싱이 만료되면 cf로 요청한다.

CF 에서 아직 캐싱이 유요하다면 cache hit 이고 cloud front 에 캐싱 된 object etag 와 비교하여 변경된게 없으면 304 status 를 response 한다.

Browser Request Header
- cache-control: max-age=0 
- if-modified-since: Tue, 27 Sep 2022 02:37:48 GMT
- if-none-match: "7ajsdklfjalskdnvklznxcklvjlzdksjfkla"

본 헤더의 의미는 Browser에 컨텐츠가 캐시되어 있으며, Browser에 캐시된 컨텐츠를 사용하기 위해 유효한지 확인을 위해 브라우저->CloudFront로 유효성 검사 요청입니다.

(if-modified-since, if-none-match은 이전에 컨텐츠가 수신/캐시되었을때 응답 헤더에서 확인된 Last-modified, Etag 값 이용)

CloudFront에서는 유효성 검사시 위의 값을 비교하여 결과가 유효한 경우 304 Not modified로 응답 헤더만 전달하며,

유효하지 않은 경우 200 OK로 신규 컨텐츠 전달합니다.

해당 요청을 보낸 주체는 Browser이며, 그 요청을 수신하여 맞는 응답을 전달한 것은 CloudFront의 PoP입니다.