풀이

import java.io.*;
import java.util.*;

public class Main {
    static int N,K,ans;
    static int[] map;
     public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = Integer.parseInt(st.nextToken());
        K = Integer.parseInt(st.nextToken());
        map = new int[100_001];

        dfs(N);
    }
    static void dfs(int n) {
        Queue<Integer> q = new ArrayDeque<>();
        q.add(n);

        map[n] = 1;

        while(!q.isEmpty()){
            int now = q.poll();

            if (now == K) {
                System.out.println(map[now] - 1); // 맨처음 시작
            }
            if (now - 1 >= 0 && map[now - 1] == 0) {
                map[now - 1] = map[now] + 1;
                q.add(now - 1);
            }
            if (now + 1 <= 100000 && map[now + 1] == 0) {
                map[now + 1] = map[now] + 1;
                q.add(now + 1);
            }
            if (2 * now <= 100000 && map[2 * now] == 0) {
                map[2 * now] = map[now] + 1;
                q.add(2 * now);
            }

        }
    }

}

BFS는 레벨별로 탐색을 진행하기 때문에 최단 경로 문제에 적합하다~!

map[n] = 1;
...
System.out.println(map[now] - 1);

• 시작점이 같을때도 한번에 처리 가능!

처음엔 dfs로 풀었는데 "시간초과" 발생!

import java.io.*;
import java.util.*;

public class Main2 {
    static int N, K, ans;
    static boolean[] visited;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = Integer.parseInt(st.nextToken());
        K = Integer.parseInt(st.nextToken());
        visited = new boolean[100_001];
        ans = Integer.MAX_VALUE;

        dfs(N, 0);
        System.out.println(ans);
    }

    static void dfs(int n, int cnt) {
        if (n < 0 || n > 100000 || visited[n]) {
            return;
        }

        if (n == K) {
            ans = Math.min(ans, cnt);
            return;
        }

        visited[n] = true;

        dfs(n - 1, cnt + 1);
        dfs(n + 1, cnt + 1);
        dfs(2 * n, cnt + 1);

        visited[n] = false;
    }
}

위풀이는 너무 많은 재귀를 하게 됨!

첫 풀이

import java.io.*;
import java.util.*;

public class Main {
    static int N, M, r, c, d, ans;
    static int[] dx = {-1, 0, 1, 0};
    static int[] dy = {0, 1, 0, -1};
    static int[][] map;
    static boolean[][] cleaned;
    static class Robot{
        int x,y,d;
        public Robot(int x, int y, int d){
            this.x = x;
            this.y = y;
            this.d = d;
        }
        private void turnLeft(){
            this.d = (this.d + 3) % 4;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        map = new int[N][M];
        cleaned = new boolean[N][M];
        st = new StringTokenizer(br.readLine());
        r = Integer.parseInt(st.nextToken());
        c = Integer.parseInt(st.nextToken());
        d = Integer.parseInt(st.nextToken());
        Robot robot = new Robot(r, c, d);

        for(int i = 0; i < N; i++){
            st = new StringTokenizer(br.readLine());
            for(int j = 0; j < M; j++){
                map[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        while(true){
            if(!cleaned[robot.x][robot.y]){
                cleaned[robot.x][robot.y] = true;
                ans++;
            }

            boolean moved = false;

            for(int i = 0; i < 4; i++){
                int nx = robot.x + dx[i];
                int ny = robot.y + dy[i];

                if(nx >= 0 && nx < N && ny >= 0 && ny < M && !cleaned[nx][ny] && map[nx][ny] == 0){
                    moved = true;
                    break;
                }
            }

            if(moved){
                robot.turnLeft();
                int nx = robot.x + dx[robot.d];
                int ny = robot.y + dy[robot.d];
                if(nx >= 0 && nx < N && ny >= 0 && ny < M && !cleaned[nx][ny] && map[nx][ny] == 0){
                    robot.x = nx;
                    robot.y = ny;
                }
            }
            if(!moved){
                int backDir = (robot.d + 2) % 4;
                int nx = robot.x + dx[backDir];
                int ny = robot.y + dy[backDir];

                if(nx >= 0 && nx < N && ny >= 0 && ny < M && map[nx][ny] != 1){
                    robot.x = nx;
                    robot.y = ny;
                    continue;
                }
                break;
            }

        }

        System.out.print(ans);
    }
}

움직임 가능 처리 조건문의 오류

if(nx >= 0 && nx < N && ny >= 0 && ny < M && !cleaned[nx][ny])

벽도 청소가 안된 상태라는 것을 깜빡하고 조건문을 잘못 짰었다! 청소가 되었어도 후진은 할수 있다!

개선

어짜피 주변의 청소되지 않은 칸으로 이동하는 것이라면 🤔 for(int i = 0; i < 4; i++)으로 순으로 dx[i], dy[i] 를 찾는 것이 아닌 turnLeft 메소드로 이동가능 여부를 판단해도 될듯하다! 👉 어짜피 움직일 칸이 없으면 다시 원래 방향을 바라보게 된다! (4번 반시계 회전)

import java.io.*;
import java.util.*;

public class Main {
    static int N, M, r, c, d, ans;
    static int[] dx = {-1, 0, 1, 0};
    static int[] dy = {0, 1, 0, -1};
    static int[][] map;
    static boolean[][] cleaned;
    static class Robot{
        int x,y,d;
        public Robot(int x, int y, int d){
            this.x = x;
            this.y = y;
            this.d = d;
        }
        private void turnLeft(){
            this.d = (this.d + 3) % 4;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        map = new int[N][M];
        cleaned = new boolean[N][M];
        st = new StringTokenizer(br.readLine());
        r = Integer.parseInt(st.nextToken());
        c = Integer.parseInt(st.nextToken());
        d = Integer.parseInt(st.nextToken());
        Robot robot = new Robot(r, c, d);

        for(int i = 0; i < N; i++){
            st = new StringTokenizer(br.readLine());
            for(int j = 0; j < M; j++){
                map[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        while(true){
            if(!cleaned[robot.x][robot.y]){
                cleaned[robot.x][robot.y] = true;
                ans++;
            }

            boolean moved = false;

            for(int i = 0; i < 4; i++){
                robot.turnLeft();
                int nx = robot.x + dx[robot.d];
                int ny = robot.y + dy[robot.d];

                if(nx >= 0 && nx < N && ny >= 0 && ny < M && !cleaned[nx][ny] && map[nx][ny] == 0){
                    moved = true;
                    robot.x = nx;
                    robot.y = ny;
                    break;
                }
            }

            if(!moved){
                int backDir = (robot.d + 2) % 4;
                int nx = robot.x + dx[backDir];
                int ny = robot.y + dy[backDir];

                if (nx < 0 || ny < 0 || nx >= N || ny >= M || map[nx][ny] == 1) {
                    break;
                }
                robot.x = nx;
                robot.y = ny;
            }
        }
        System.out.print(ans);
    }
}

풀이

class Solution {
    static int[] numbers;
    static int N;
    static int target;
    static int count = 0;

    public int solution(int[] numbers, int target) {
        Solution.numbers = numbers;
        N = numbers.length;
        Solution.target = target;
        dfs(0, 0);
        return count;
    }

    static void dfs(int idx, int sum) {
        if (idx == N) {
            if (sum == target) {
                count++;
            }
            return;
        }

        dfs(idx + 1, sum + numbers[idx]);

        dfs(idx + 1, sum - numbers[idx]);
    }
}

static 변수를 두고 푸는게 편하게 느껴진다.

풀이

import java.util.*;

class Solution {
    public String solution(int[] numbers) {
        // int 배열을 String 배열로 변환
        String[] strNumbers = new String[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            strNumbers[i] = String.valueOf(numbers[i]);
        }

        Arrays.sort(strNumbers, (s1, s2) -> (s2 + s1).compareTo(s1 + s2));

        if (strNumbers[0].equals("0")) {
            return "0";
        }

        StringBuilder sb = new StringBuilder();
        for (String str : strNumbers) {
            sb.append(str);
        }

        return sb.toString();
    }
}

👉 정렬

Arrays.sort(strNumbers, (s1, s2) -> (s2 + s1).compareTo(s1 + s2));

s1 = "3", s2 = "30": s2 + s1 = "303" s1 + s2 = "330" ("303").compareTo("330")은 -1을 반환합니다. 👉 즉, "30"이 "3"보다 앞에 위치해야 합니다. 쉽게 말해서 더 큰쪽으로 정렬된다!

(s2 + s1).compareTo(s1 + s2): 더 큰 쪽을 앞에 배치 (내림차순 정렬) 이 문제
(s1 + s2).compareTo(s2 + s1): 더 작은 쪽을 앞에 배치 (오름차순 정렬)

오답 풀이

import java.util.*;

class Solution {
    public int solution(int[] scoville, int K) {
        int answer = 0;
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        int N = scoville.length;

        for(int i = 0; i < N; i++){
            pq.offer(scoville[i]);
        }

        while(pq.size() >= 2){
            answer++;
            int sum = 0;
            int a = pq.poll();
            int b = pq.poll();
            sum = a + 2*b;
            pq.offer(sum);

            if(pq.peek() >= K){
                return answer;
            }
        }

        if(pq.peek() >= K){
            return answer;
        }else{
            return -1;
        }


    }
}

• 이렇게 풀면 처음부터 전부가 K 이상일 경우를 정확하게 잡아내지 못함!
• 무조건 섞고 판단하게 된다!

📌 처음에 섞지 않고도 만족하는 경우를 고려하지 못했다!

• 조건문을 좀 더 심도있게 세우자

재풀이

import java.util.*;

class Solution {
    public int solution(int[] scoville, int K) {
        int answer = 0;
        PriorityQueue<Integer> pq = new PriorityQueue<>();

        for (int scov : scoville) {
            pq.offer(scov);
        }

        while (pq.size() > 1 && pq.peek() < K) {
            int a = pq.poll();
            int b = pq.poll();
            int newScoville = a + 2 * b;
            pq.offer(newScoville);
            answer++;
        }

        if (pq.peek() < K) {
            return -1;
        } else {
            return answer;
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    static int N, S, M;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = Integer.parseInt(st.nextToken()); // 곡의 갯수
        S = Integer.parseInt(st.nextToken()); // 처음 볼륨
        M = Integer.parseInt(st.nextToken()); // 최대 볼륨

        st = new StringTokenizer(br.readLine());

        // 각 곡의 볼륨 변화 (N+1 크기로 선언)
        int[] V = new int[N + 1];

        for (int i = 1; i <= N; i++) {  // i는 1부터 시작
            V[i] = Integer.parseInt(st.nextToken());
        }

        // dp[i][j] : i번째 곡까지 연주했을 때 볼륨이 j인 경우 가능 여부 (true: 가능, false: 불가능)
        boolean[][] dp = new boolean[N + 1][M + 1];
        dp[0][S] = true; // 초기 볼륨으로 시작

        // 이전 값을 보고 현재 가능한 경우의 수 처리!
        for (int i = 1; i <= N; i++) {
            for (int j = 0; j <= M; j++) {
                if (dp[i - 1][j]) {
                    if (j + V[i] <= M) {
                        dp[i][j + V[i]] = true;
                    }
                    if (j - V[i] >= 0) {
                        dp[i][j - V[i]] = true;
                    }
                }
            }
        }

        // 마지막 곡까지 연주했을 때 가능한 최대 볼륨 찾기
        int maxVolume = -1;
        for (int i = M; i >= 0; i--) {
            if (dp[N][i]) {
                maxVolume = i;
                break;
            }
        }
        System.out.println(maxVolume);
    }
}

N = 3 (곡의 개수)
S = 5 (시작 볼륨)
M = 10 (최대 볼륨)
볼륨 변화량 = [5, 3, 7]

dp 테이블을 채우는 방식 차이

 for (int i = 1; i <= N; i++) {
            for (int j = 0; j <= M; j++) {
                if (dp[i - 1][j]) {
                    if (j + V[i] <= M) {
                        dp[i][j + V[i]] = true;
                    }
                    if (j - V[i] >= 0) {
                        dp[i][j - V[i]] = true;
                    }
                }
            }
        }

이전 곡(i-1)에서 현재 볼륨 j를 만들 수 있는지(dp[i-1][j])를 확인하고, 현재 곡(i)에서 볼륨 변화량 V[i]를 더하거나 빼서 새로운 볼륨을 만듬

• 이 방식은 이전 상태(i-1)에서 현재 상태(i)로 볼륨을 업데이트하는 접근 방식

for (int i = 1; i <= N; i++) {
            for (int j = 0; j <= M; j++) {
                // 볼륨 줄이기 (-)
                if (j - V[i] >= 0 && dp[i - 1][j - V[i]]) {
                    dp[i][j] = true;
                }
                // 볼륨 올리기 (-)
                if (j + V[i] <= M && dp[i - 1][j + V[i]]) {
                    dp[i][j] = true;
                }
            }
        }

현재 볼륨 j를 만들기 위해 이전 곡(i-1)에서 가능한 모든 경우를 체크

• 이 방식은 현재 상태(i)에서 이전 상태(i-1)를 참고하여 볼륨을 업데이트하는 접근 방식

차이점

업데이트 시점

• 첫 번째 방식: 이전 상태(i-1)에서 가능한 모든 볼륨을 확인하고, 현재 상태(i)의 볼륨을 업데이트
• 두 번째 방식: 현재 상태(i)의 볼륨을 만들기 위해 이전 상태(i-1)에서 가능한 모든 경우를 체크

루프 구조

• 첫 번째 방식: 이전 상태의 볼륨을 기반으로 현재 상태의 새로운 볼륨을 직접 업데이트.
• 두 번째 방식: 현재 상태의 볼륨을 만들기 위해 이전 상태의 볼륨을 역으로 추적하여 업데이트.

🤔 뭐가 더 좋을까?

• 첫 번째 방식 내부 루프에서 조건문을 통해 볼륨을 더하고 빼는 경우를 따로 체크 dp[i - 1][j]가 true인 경우에만 업데이트하므로, 불필요한 연산이 줄어듬

• 두 번째 방식 모든 볼륨 범위에서 이전 곡의 볼륨을 줄이거나 늘리는 경우를 체크 모든 경우를 다 체크하므로, 경우에 따라 더 많은 연산이 필요할 수 있음

👉 첫 번째 방식이 더 나은 선택일 가능성이 크다!

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = Integer.parseInt(br.readLine()); // 테스트 케이스 개수

        for (int t = 0; t < T; t++) {
            int N = Integer.parseInt(br.readLine()); // 스티커 개수
            int[][] sticker = new int[2][N + 1]; // 스티커 정보 저장 (0: 첫 번째 줄, 1: 두 번째 줄)

            // 스티커 정보 입력
            for (int i = 0; i < 2; i++) {
                StringTokenizer st = new StringTokenizer(br.readLine());
                for (int j = 1; j <= N; j++) {
                    sticker[i][j] = Integer.parseInt(st.nextToken());
                }
            }

            // DP 테이블 초기화
            int[][] dp = new int[2][N + 1];
            dp[0][1] = sticker[0][1];
            dp[1][1] = sticker[1][1];

            // DP 계산
            for (int i = 2; i <= N; i++) {
                dp[0][i] = Math.max(dp[1][i - 1], dp[1][i - 2]) + sticker[0][i];
                dp[1][i] = Math.max(dp[0][i - 1], dp[0][i - 2]) + sticker[1][i];
            }

            // 최대 점수 출력
            System.out.println(Math.max(dp[0][N], dp[1][N]));
        }
    }
}

DP 배열의 선택 기준

각 위치에서 가능한 선택 : "현재 위치의 대각선에 있는 값"과 "대각선 왼쪽에 있는 값"

1. 대각선 위치 (i-1)

현재 위치의 스티커를 선택하면 바로 위/아래의 스티커는 선택할 수 없기 때문에 대각선 위치에 있는 스티커 값을 참고!

50 10 100 20 40
30 50 70 10 60

예를 들어 dp[0][i]를 계산할 때 dp[1][i-1]를 참고하는 이유는
sticker[1][i-1]은 sticker[0][i]와 인접하지 않기 때문

2. 대각선의 왼쪽 위치 (i-2)

dp[1][i-2] 같은 경우도 인접하지 않은 스티커

50 10 100 20 40
30 50 70 10 60

dp[0][i]를 계산할 때 dp[1][i-2]를 참고하는 이유는 
더 먼 거리에 있는 스티커를 선택함으로써 인접하지 않은 최대 점수를 얻을 수 있기 때문

🤔 왜 같은 줄에서 두 칸 떨어진 위치를 참고 X?

👉 이전에 선택된 스티커와의 인접성 중간에 있는 스티커가 무시될 위험이 있음!

50 10 100 20 40
30 50 70 10 60

sticker[0][2]를 선택하고 sticker[0][4]를 선택하면
중간에 있는 sticker[0][3]을 고려하지 않게 되니까 인접한 스티커들을 제대로 체크하지 못함

즉 선택기준은 👉 대각선에 있는 친구가 선택되었을때 vs 선택 안되었을때! dp[0][i]를 계산할 때 sticker[1][i-1]가 선택되었을 때와 선택되지 않았을 때의 점수를 비교하는 방식!

DP를 활용한 문제

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;

public class Main {

    final static int Red = 0;
    final static int Green = 1;
    final static int Blue = 2;

    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        int N = Integer.parseInt(br.readLine());

        int[][] dp = new int[N + 1][3];

        for (int i = 1; i <= N; i++) {
            st = new StringTokenizer(br.readLine());

            int r = Integer.parseInt(st.nextToken());
            int g = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());

            dp[i][Red] = Math.min(dp[i - 1][Green], dp[i - 1][Blue]) + r;
            dp[i][Green] = Math.min(dp[i - 1][Red], dp[i - 1][Blue]) + g;
            dp[i][Blue] = Math.min(dp[i - 1][Red], dp[i - 1][Green]) + b;
        }

        System.out.println(Math.min(dp[N][0], Math.min(dp[N][1], dp[N][2])));

    }

}

1. DP 테이블 초기화

dp는 2차원 배열로, dp[i][j]는 i번째 집을 j 색깔로 칠했을 때의 최소 비용을 나타냄!

2. DP 계산

i번째 집을 칠할 때, 인접한 집의 색상을 고려하여 최소 비용을 계산

• i번째 집을 빨간색으로 칠할 때, i-1번째 집은 초록색 또는 파란색으로 칠해야 함
• dp[i][Red]는 dp[i-1][Green]과 dp[i-1][Blue] 중 작은 값에 현재 집의 빨간색 비용을 더한 값 👉 현재 Red 비용값 + Math.min( 이전 누적 Green 비용값 ,이전 누적 Blue 비용값 )

  dp[i][Red] = Math.min(dp[i - 1][Green], dp[i - 1][Blue]) + r;

이와 같은 방식으로 초록색과 파란색 비용도 계산!

3. 최소 비용 출력

마지막 집(N번째 집)을 빨간색, 초록색, 파란색으로 칠했을 때의 최소 비용 중 가장 작은 값을 출력!

Math.min(dp[N][0], Math.min(dp[N][1], dp[N][2]))

2번째 풀이

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    static int N;
    static final int RED = 0;
    static final int GREEN = 1;
    static final int BLUE = 2;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        N = Integer.parseInt(br.readLine()); // 집
        int[] R = new int[N + 1];
        int[] G = new int[N + 1];
        int[] B = new int[N + 1];

        for(int i = 1; i <= N; i++){
            StringTokenizer st = new StringTokenizer(br.readLine());
            R[i] = Integer.parseInt(st.nextToken());
            G[i] = Integer.parseInt(st.nextToken());
            B[i] = Integer.parseInt(st.nextToken());
        }

        int[][] dp = new int[N + 1][3];

        // 1번 집 초기화
        dp[1][RED] = R[1];
        dp[1][GREEN] = G[1];
        dp[1][BLUE] = B[1];

        for (int i = 2; i <= N; i++) {
            for (int j = 0; j < 3; j++) {
                if (j == RED) {
                    dp[i][j] = Math.min(dp[i - 1][GREEN], dp[i - 1][BLUE]) + R[i];
                }
                if (j == GREEN) {
                    dp[i][j] = Math.min(dp[i - 1][RED], dp[i - 1][BLUE]) + G[i];
                }
                if (j == BLUE) {
                    dp[i][j] = Math.min(dp[i - 1][RED], dp[i - 1][GREEN]) + B[i];
                }
            }
        }

        /**
        for (int i = 2; i <= N; i++) {
            // 지금 탐색하는 집이 해당 색으로 칠해질때의 최소 비용 계산
            dp[i][RED] = Math.min(dp[i - 1][GREEN], dp[i - 1][BLUE]) + R[i];
            dp[i][GREEN] = Math.min(dp[i - 1][RED], dp[i - 1][BLUE]) + G[i];
            dp[i][BLUE] = Math.min(dp[i - 1][RED], dp[i - 1][GREEN]) + B[i];
        }
        */

        int ans = Math.min(dp[N][BLUE], Math.min(dp[N][RED], dp[N][GREEN]));

        System.out.print(ans);

    }
}

만약 여기서

R, G, B .... 배열의 종류가 많아진다면 cost 2차원 배열을 두고 계산하는 것이 낫곘다!

int[][] cost = new int[N + 1][3]; // cost 

        for(int i = 1; i <= N; i++){
            StringTokenizer st = new StringTokenizer(br.readLine());
            cost[i][RED] = Integer.parseInt(st.nextToken());
            cost[i][GREEN] = Integer.parseInt(st.nextToken());
            cost[i][BLUE] = Integer.parseInt(st.nextToken());
        }

스프링 컨테이너가 관리하는 자바 객체를 의미합니다. 빈은 인스턴스화된 객체를 의미하며, 스프링 컨테이너에 등록된 객체를 스프링 빈이라고 합니다.

<bean id="hello" class="com.example.Hello"/>
이렇게 xml 파일 빈 태그를 추가하면 hello 인스턴스를 스프링 컨테이너가 관리하게 됩니다.

Hello hello = new Hello()
즉 new 키워드 대신 사용하는 것!

🧐 ApplicationContext 이란?

ApplicationContext는 Spring Container의 구현체 중 하나로, 객체의 생성과 소멸 라이프사이클을 관리합니다. 즉 애플리케이션의 빈(Bean)들을 관리하고 필요한 객체를 제공하는 역할을 합니다.

1. 객체의 생성과 소멸 라이프사이클 관리: ApplicationContext는 설정된 빈의 라이프사이클을 관리합니다. 이를 통해 개발자는 빈의 라이프사이클에 관여하지 않고도 안정적으로 객체를 사용할 수 있습니다.
2. Configuration Metadata 필요: ApplicationContext를 구성하는 빈들은 Spring의 설정 문서 또는 Configuration Metadata를 필요로 합니다. 이는 XML 파일이나 JavaConfig 같은 설정 방법을 통해 정의될 수 있습니다. 이 설정 문서에는 애플리케이션에서 사용될 빈의 정보, 의존성, 빈의 스코프 등이 정의됩니다.
3. 미리 객체를 만들어 놓는다 (사전 초기화): ApplicationContext는 빈을 미리 생성하고 필요할 때 제공하는 방식으로 동작합니다. 따라서 ApplicationContext가 로드될 때 설정된 빈들은 미리 생성되어 초기화됩니다. 이를 통해 애플리케이션이 시작될 때 필요한 객체들이 준비되어 있어야 할 때 속도와 효율성이 향상됩니다.
4. Scope 설정: ApplicationContext를 통해 생성되는 빈들은 기본적으로 싱글톤(Singleton) 스코프를 갖습니다. 이는 ApplicationContext가 단일 인스턴스를 생성하고 해당 인스턴스를 모든 요청에 대해 공유하는 것을 의미합니다. 또한, Prototype 스코프를 설정할 수도 있으며, 이는 각 요청에 대해 새로운 인스턴스를 생성하여 제공합니다. 이를 통해 빈의 스코프를 설정하여 객체의 생명주기를 관리할 수 있습니다.

🧪 Test 1 : 빈의 스코프 "singleton" vs "prototype"

public interface MessageBean {
    void sayHello(String name);
}


1. MessageBeanEnImpl
public class MessageBeanEnImpl implements MessageBean{
    public MessageBeanEnImpl() {
        System.out.println("MessageBeanEnImpl 생성자 호출됨");
    }
    public void sayHello(String name) {
        System.out.println("nice to meet you!" + name);
    }

}

2. MessageBeanKoImpl
public class MessageBeanKoImpl implements MessageBean{
    public MessageBeanKoImpl() {
        System.out.println("MessageBeanKoImpl 생성자 호출됨");
    }
    public void sayHello(String name) {
        System.out.println(name + " 님 방가방가");
    }
}

기존 java의 생성 방식

MessageBean bean = new MessageBeanEnImpl();
bean.sayHello("Bong");

bean = new MessageBeanKoImpl();
bean.sayHello("봉");

applicationContext.yml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean class="sample01.MessageBeanKoImpl" id="ko" scope="singleton"></bean>
      <bean class="sample01.MessageBeanKoImpl" id="ko2"/>
    <bean class="sample01.MessageBeanEnImpl" id="en"/>

</beans>

• Bean 하나당 한개의 객체 생성 ( 기본값이 singleton )

• scope = "prototype" 으로 하면 각 다른 객체 만들어집니다.

  • 미리 생성을 하지않고 지연초기화(지연로딩)
  • getBean() 요청할때 마다 만들기 때문에 각 새로운 객체 만들어 지게 됩니다.

• ko 와 ko2는 각각 빈으로 등록된것!

public class MainTest {
    public static void main(String[] args) {

        //스프링 컨테이너는 설정문서 기반으로 만들어지는것 ! (classPath를 기준 경로)
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");

        MessageBean bean = context.getBean("en", MessageBean.class); // context.getBean(String Id, class)
        bean.sayHello("Bong");

        bean = context.getBean("ko", MessageBean.class);
        bean.sayHello("봉");

        //getBean 할때마다 새롭게 만드나?? 아니면 만든거 사용하는건가?? - 동일한 객체!
        MessageBean bean2 = context.getBean("ko", MessageBean.class); // id가 동일하게 getBean()

        System.out.println("bean = " + bean);
        System.out.println("bean2 = " + bean2);
        //주소값이 같음! 즉, 싱글톤으로 관리되는 객체와 같음 (static class)
        //사전초기화 , 미리 객체를 만들어 놓음 !
        //bean 하나당 1객체

    }
}

- 만약 scope="prototype" 라면 ->  prototype 으로 하면 각 다른 객체 만들어짐! 즉 미리 생성을 안함! 지연초기화(지연로딩)
 * MessageBeanEnImpl 생성자 호출됨 - En은  singleton
 * MessageBeanKoImpl 생성자 호출됨 - 필요할때 생성
 * nice to meet you!Bong
 * MessageBeanKoImpl 생성자 호출됨 - 필요할때 생성
 * 봉 님 방가방가
 * MessageBeanKoImpl 생성자 호출됨 - Ko 하나더 생성
 * bean = sample01.MessageBeanKoImpl@23348b5d
 * bean2 = sample01.MessageBeanKoImpl@70325e14

 - 만약 scope = "singleton" 이면 -> 미리 객체를 만들어 놓음 (기본값)
 * MessageBeanKoImpl 생성자 호출됨
 * MessageBeanEnImpl 생성자 호출됨
 * MessageBeanKoImpl 생성자 호출됨 - 미리 생성
 * nice to meet you!Bong
 * 봉 님 방가방가
 * bean = sample01.MessageBeanKoImpl@2df3b89c
 * bean2 = sample01.MessageBeanKoImpl@2df3b89c

🧪 Test 2 : 여러 생성자 테스트

Member.java

@ToString
public class Member {
    private String id;
    private String pwd;
    private int age;
    private String addr;
    public Member() {
        System.out.println("Member 기본생성자");
    }
    public Member(String id) {
        System.out.println("Member(String id) 생성자");
        this.id = id;
    }
    public Member(String id ,String pwd) {
        System.out.println("Member(String id ,String pwd) 생성자");
        this.id = id;
        this.pwd = pwd;
    }
    public Member(String id ,int age) {
        System.out.println("Member(String id ,int age) 생성자");
        this.id = id;
        this.age = age;
    }
    public Member(String id, int age, String addr) {
        System.out.println("Member(String id, int age, String addr) 생성자");

        this.id = id;
        this.age = age;
        this.addr = addr;
    }
    public Member(String id, String pwd, int age, String addr) {
        this.id = id;
        this.pwd = pwd;
        this.age = age;
        this.addr = addr;
        System.out.println("Member(String id, String pwd, int age, String addr) 생성자");

    }
}

MemberDao.java

public class MemberDao {
    public MemberDao() {
        System.out.println("MemberDao 생성자입니다.");
    }

    public void insert(Member member) {
        System.out.println("MemberDao의 insert 호출됨....");
        System.out.println("member = " + member);
    }
}

MemberService

public class MemberService {
    private MemberDao memberDao;
    private Member member;

    public  MemberService() {
        System.out.println("MemberService 생성자 호출");
    }

    public MemberService(MemberDao memberDao, Member member) {
        this.memberDao = memberDao;
        this.member = member;
        System.out.println("MemberService(MemberDao memberDao, Member member) 생성자 호출");
        System.out.println("memberDao =" + memberDao);
        System.out.println("member =" + member);
    }

    public void serviceInsert() {
        System.out.println("MemberService의 serviceInsert 호출됨...");
        memberDao.insert(member);
    }
}

springDI.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    1. 기본생성자
    <bean class="sample02.Member" id="m1"/>

    2. 인수 1개 받는 생성자
    <bean class="sample02.Member" id="m2">
        <constructor-arg value="jang"/>
    </bean>

    3. 인수 2개 받는 생성자
    <bean class="sample02.Member" id = "m3">
        <constructor-arg value="kim"/>
        <constructor-arg value="20" type="int"/>
    </bean>
          인수가 2개 받는 생성자가 2개! -> 갯수가 2개인 애들 먼저 찾음
          type 명시 안하면 코드상 가장 먼저있는 인수 2개 받는 생성자 호출

    4. 인수 4개 받는 생성자
    <bean class="sample02.Member" id ="m4">
        <constructor-arg value="king" index="0" />
        <constructor-arg value="30" index="2"/>
        <constructor-arg value="서울" index="3"/>
        <constructor-arg value="1234" index="1"/>
    </bean>
          순서 안맞추면 에러 떨어짐 index 써줘서 맞춰주기!

      5. MemberDao 생성자
    <bean class="sample02.MemberDao" id="dao"/>

      6. MemberService 인수 2개 받는 생성자
    <bean class="sample02.MemberService" id="service">
        <constructor-arg ref="dao"/>
        <constructor-arg ref="m4"/>
    </bean>
          기본생성자로 생성하면 Member와 MemberDAO가 초기화되지 않음
        생성자를 이용한 주입(DI) - m4 넣어줌
              1) value : 일반타입 (프리미트 타입)
               2) ref : 객체

</beans>

기존 방식

Member member = new Member("jang", "1234", 20, "서울");
MemberDao memberDao = new MemberDao();
MemberService service = new MemberService(memberDao, member);
service.serviceInsert();

public class MainTest {
    public static void main(String[] args) {

        ApplicationContext context
                = new ClassPathXmlApplicationContext("springDI.xml");

        System.out.println("---------------------------");

        MemberService service = context.getBean("service", MemberService.class);
        service.serviceInsert();
    }
}

1. Member 기본생성자
2. Member(String id) 생성자
3. Member(String id ,int age) 생성자
4. Member(String id, String pwd, int age, String addr) 생성자
5. MemberDao 생성자입니다.
6. MemberService(MemberDao memberDao, Member member) 생성자 호출
    memberDao = MemberDao()
    member = Member(id=king, pwd=1234, age=30, addr=서울)

-------------------------------------------

MemberService의 serviceInsert 호출됨...
MemberDao의 insert 호출됨...
member = Member(id=king, pwd=1234, age=30, addr=서울)

1. vi docker-compose.yml

로컬에 다운받은 카프카 폴더에서 yml 파일 편집

version: '2.1'

services:
  zoo1:
    image: confluentinc/cp-zookeeper:latest
    hostname: zoo1
    container_name: zoo1
    ports:
      - "2182:2181"
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_SERVER_ID: 1
      ZOOKEEPER_SERVERS: zoo1:2888:3888

  kafka1:
    image: confluentinc/cp-kafka:latest
    hostname: kafka1
    container_name: kafka1
    ports:
      - "9093:9093"
      - "29093:29093"
    environment:
      KAFKA_ADVERTISED_LISTENERS: INTERNAL://kafka1:19093,EXTERNAL://localhost:9093,DOCKER://host.docker.internal:29093
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: INTERNAL:PLAINTEXT,EXTERNAL:PLAINTEXT,DOCKER:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: INTERNAL
      KAFKA_ZOOKEEPER_CONNECT: "zoo1:2181"
      KAFKA_BROKER_ID: 1
      KAFKA_LOG4J_LOGGERS: "kafka.controller=INFO,kafka.producer.async.DefaultEventHandler=INFO,state.change.logger=INFO"
      KAFKA_AUTHORIZER_CLASS_NAME: kafka.security.authorizer.AclAuthorizer
      KAFKA_ALLOW_EVERYONE_IF_NO_ACL_FOUND: "true"
    depends_on:
      - zoo1

  kafka2:
    image: confluentinc/cp-kafka:latest
    hostname: kafka2
    container_name: kafka2
    ports:
      - "9094:9094"
      - "29094:29094"
    environment:
      KAFKA_ADVERTISED_LISTENERS: INTERNAL://kafka2:19094,EXTERNAL://localhost:9094,DOCKER://host.docker.internal:29094
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: INTERNAL:PLAINTEXT,EXTERNAL:PLAINTEXT,DOCKER:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: INTERNAL
      KAFKA_ZOOKEEPER_CONNECT: "zoo1:2181"
      KAFKA_BROKER_ID: 2
      KAFKA_LOG4J_LOGGERS: "kafka.controller=INFO,kafka.producer.async.DefaultEventHandler=INFO,state.change.logger=INFO"
      KAFKA_AUTHORIZER_CLASS_NAME: kafka.security.authorizer.AclAuthorizer
      KAFKA_ALLOW_EVERYONE_IF_NO_ACL_FOUND: "true"
    depends_on:
      - zoo1

  kafka3:
    image: confluentinc/cp-kafka:latest
    hostname: kafka3
    container_name: kafka3
    ports:
      - "9095:9095"
      - "29095:29095"
    environment:
      KAFKA_ADVERTISED_LISTENERS: INTERNAL://kafka3:19095,EXTERNAL://localhost:9095,DOCKER://host.docker.internal:29095
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: INTERNAL:PLAINTEXT,EXTERNAL:PLAINTEXT,DOCKER:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: INTERNAL
      KAFKA_ZOOKEEPER_CONNECT: "zoo1:2181"
      KAFKA_BROKER_ID: 3
      KAFKA_LOG4J_LOGGERS: "kafka.controller=INFO,kafka.producer.async.DefaultEventHandler=INFO,state.change.logger=INFO"
      KAFKA_AUTHORIZER_CLASS_NAME: kafka.security.authorizer.AclAuthorizer
      KAFKA_ALLOW_EVERYONE_IF_NO_ACL_FOUND: "true"
    depends_on:
      - zoo1

로컬 2182 포트로 주키퍼 접속 (내부적으론 2181) 카프카 1 : 9093 포트 카프카 2 : 9094 포트 카프카 3 : 9095 포트

    ports:
      - "9095:9095"
      - "29095:29095"

9095:9095: 이 부분은 호스트의 9095 포트를 컨테이너의 9095 포트로 매핑 -> 호스트에서 Kafka 브로커에 접속할 때 9095 포트를 사용한다는 의미 29095:29095: Docker 내부 네트워크에서의 포트 매핑을 정의 -> 컨테이너 내부에서 Kafka 브로커에 접속할 때 사용할 포트 지정. 컨테이너 내부에서 29095 포트를 사용하여 Kafka 브로커에 접속할 수 있음.

1. 실행

$docker-compose -f docker-compose.yml up -d # yml에 포함된 컨테이너들 올리는 명령어
$docker ps # docker ps 명령어로 잘 돌아가나 확인

2. 토픽생성

# 로컬 카프카 폴더내에서
./bin/kafka-topics.sh --create \
    --replication-factor 3 \
    --partitions 3 \
    --topic app-push-topic \
    --bootstrap-server localhost:9093,localhost:9094,localhost:9095

• "app-push-topic"이라는 토픽을 생성하며, 각 파티션에는 3개의 복제본이 있고, 파티션 수는 3개
• 실행하면 Kafka 클러스터 내에서 해당 토픽이 생성되고, 관련된 브로커 간에 파티션 복제가 설정됨

  # 토픽 상세 조회
  ./bin/kafka-topics.sh --describe \
    --topic app-push-topic \
    --bootstrap-server localhost:9093,localhost:9094,localhost:9095
  

#결과 Topic: app-push-topic TopicId: C__MUpdpTv-Ej1s8Empw8A PartitionCount: 3 ReplicationFactor: 3 Configs: Topic: app-push-topic Partition: 0 Leader: 1 Replicas: 1,2,3 Isr: 2,3,1 Topic: app-push-topic Partition: 1 Leader: 2 Replicas: 2,3,1 Isr: 2,3,1 Topic: app-push-topic Partition: 2 Leader: 3 Replicas: 3,1,2 Isr: 3,2,1

![](https://velog.velcdn.com/images/dumbveloper_100/post/a9b34394-7f83-4641-8788-f33c63510653/image.png)
- **Partition: 0, 1, 2**: 각 파티션의 번호
- **Leader: 1, 2, 3**: 각 파티션의 리더 브로커의 ID
- **Replicas: 1,2,3, 2,3,1, 3,1,2**: 각 파티션에 대한 복제본(Replica)의 브로커 ID 목록. 순서는 중요하지 않음!
- **Isr: 2,3,1, 2,3,1, 3,2,1**: 현재 인-시크(In-Sync Replica) 목록. 각 파티션의 리더 브로커를 포함한 현재 복제본의 목록

> 📌 ***인-시크란?***
Kafka에서 각 파티션은 여러 개의 복제본을 가질 수 있음,  이 중에서 하나는 리더이며, 나머지는 팔로워 복제본. 리더 파티션은 메시지를 쓰고 소비하는 역할을 수행하며, 팔로워 복제본들은 리더와 동기화되어 있어 리더에 장애가 발생했을 때 대체 가능.
→ 인-시크는 현재 메시지를 따라가는 동기화된 상태에 있는 복제본들을 나타냄. 즉, 인-시크에 속한 복제본들은 리더와 동일한 메시지를 가지고 있으며, 데이터의 일관성을 보장하는것 
→ 만약 리더 파티션에서 메시지를 송신하고 있는데 팔로워 중 하나가 동기화되지 못한 상태라면 해당 복제본은 인-시크에서 제외됨.

### 쉘 4개 이제 열어서 , 1개 프로듀서 3개 컨슈머 실행
```bash
# consumer jar 파일 있는 디렉토리에서
java -jar consumer-2.3.0.RELEASE.jar

# producer jar 파일 있는 디렉토리에서
java -jar producer-2.3.0.RELEASE.jar

postman으로 TEST

분산처리 확인완료

# 컨슈머 그룹 리스트 조회
./bin/kafka-consumer-groups.sh --list \
    --bootstrap-server localhost:9093,localhost:9094,localhost:9095

app-push-group

# 컨슈머 그룹 상세조회
./bin/kafka-consumer-groups.sh --describe \
    --group app-push-group \
    --bootstrap-server localhost:9093,localhost:9094,localhost:9095

GROUP           TOPIC           PARTITION  CURRENT-OFFSET  LOG-END-OFFSET  LAG             CONSUMER-ID                                                    HOST            CLIENT-ID
app-push-group  app-push-topic  0          264             264             0               consumer-app-push-group-1-a9d6852b-1f81-400b-8337-6466a1f0aab2 /192.168.65.1   consumer-app-push-group-1
app-push-group  app-push-topic  2          248             248             0               consumer-app-push-group-1-dc22572f-eddf-4ed2-8299-d6da8db4edfa /192.168.65.1   consumer-app-push-group-1
app-push-group  app-push-topic  1          270             270             0               consumer-app-push-group-1-c17f0f35-d5a2-48d4-8952-9c9f9cc820fd /192.168.65.1   consumer-app-push-group-1

• GROUP | Topic | PARTITION : 조회한 컨슈머 그룹이 마지막으로 커밋한 토픽과 파티션을 나타냄
• CURRENT-OFFSET : 컨슈머 그룹이 가져간 토픽의 파티션에 가장 최신 오프셋(offset)이 몇번 인지 나타냄
  • 오프셋 : 파티션의 각 레코드에 할당된 번호 , 데이터가 파티션에 들어올때마다 1씩 증가
• LOG-END-OFFSET : 해당 컨슈머 그룹의 컨슈머가 어느 오프셋까지 커밋했는지 알 수 있다
  • CURRENT-OFFSET ≤ LOG-END-OFFSET
• LAG : 컨슈머 그룹이 토픽의 파티션에 있는 데이터를 가져가는데 얼마나 지연이 발생하나 나타내는 지표
  • LOG-END-OFFSET(컨슈머 그룹이 커밋한 오프셋) - CURRENT-OFFSET(해당 파티션의 가장 최신 오프셋) = LAG
• CONSUMER-ID : 컨슈머의 할당을 내부적으로 구분하기 위한 id
• HOST : 컨슈머가 동작하는 host 명 , 이 값을 통해 컨슈머의 호스트명 또는 ip를 알아 낼 수 있다.
• CLIENT-ID : 컨슈머에 할당된 id , 사용자가 지정가능 , 지정하지 않으면 자동생성됨

🍀 Eureka 란?

Eureka는 클라우드 환경의 다수의 서비스(예: API 서버)들의 로드 밸런싱 및 장애 조치 목적을 가진 미들웨어서버!

로드 밸런싱 : 특정 서비스를 제공하는 서버가 여러대가 있을 때 트래픽을 한 서버에 몰리지 않게 분산해주는 기술이다. 미들웨어 : 데이터를 주고 받는 양쪽의 서비스(웹의 예로 클라이언트와 API 서버)의 중간에 위치해 매개 역할을 하는 소프트웨어다.

Eureka는 이러한 미들웨어 기능을 하기 위해 각 연결된 서비스의 IP / PORT /InstanceId를 가지고 있고 REST기반으로 작동. Eureka는 Client-Sever 방식으로 Eureka Server에 등록된 서비스는 Eureka Client로 불린다. 각 서비스를 Eureka Server에 등록하게 되면 Eureka Server는 각 Eureka Client의 IP / PORT / InstanceId를 저장한다. 이후 Eureka Client가 다른 Eureka Client에게 요청을 보낼 때 Eureka에서 받아온 정보를 가지고 요청을 보낼 수 있다.

1. Eureka server

       <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>

        <!-- 모니터링 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <!--Spring Boot Admin Server를 시작하는 데 필요한 라이브러리-->
        <!-- 2024-03-04 시점엔 3.2.3 버전 없음 -->
        <dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-server</artifactId>
            <version>3.2.2</version>
        </dependency>

@EnableAdminServer
@EnableEurekaServer
@SpringBootApplication
public class Step07SpringCloudServerApplication {

    public static void main(String[] args) { 
        SpringApplication.run(Step07SpringCloudServerApplication.class, args);
    }

}

• @EnableAdminServer : 어노테이션은 Spring Boot Admin Server를 활성화하는 데 사용, 모니터링 및 관리를 제공하는 도구.
• @EnableEurekaServer : 현재의 스프링 부트 애플리케이션을 Eureka Server로 설정

application.yml

server:
  port: 8761
spring:
  application:
    name: server
  boot:  # spring boot admin 모니터링 기능 이용을 위한 설정 부분
    admin:
      context-path: /admin
management: # 엔트포인트 노출 설정 애플리케이션을 배포하는 경우 인증 없이 모든 액추에이터 끝점에 액세스
  endpoints:
    web:
      exposure:
        include: "*"
eureka:
  instance:
    hostname: <ec2 퍼블릭IP>
    prefer-ip-address: true
  client:
    register-with-eureka: false
    service-url:
      default-zone: http://<퍼블릭IP>:8761/eureka/

2. Eureka client server

        <dependency>  
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-client</artifactId>
            <version>3.2.2</version>
        </dependency>

@EnableDiscoveryClient
@SpringBootApplication
public class Step07SpringCloudClient1ConsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(Step07SpringCloudClient1ConsumerApplication.class, args);
    }
}

• @EnableDiscoveryClient : 서비스 디스커버리 시스템에 등록되어 다른 마이크로서비스들과 통신

server:
  port: 9009
  address: <ec2 private ip>

# project 별칭 등록
# 다른 project에서 호출할때 사용되는 이름
spring:
  application:
    name: PRODUCER-SERVICE
  boot:
    admin:
      client:
        instance:
          service-url: http://<public ip>:9009
# 애플리케이션의 상태, 메모리 사용량, 데이터베이스 연결 상태 등을 모니터링하고 관리하기 위한 설정         
# Spring Boot Actuator를 사용하여 애플리케이션의 상태를 모니터링하고 관리 가능
# 필요한 경우 설정을 조정하여 원하는 엔드포인트를 노출하여 관리 가능        
management: 
  endpoints:
    web:
      exposure:
        include: "*"

eureka:
  instance:
    prefer-ip-address: true
    ip-address: ${server.address}
    instance-id: ${server.address}:${spring.application.name}:${server.port} # spring Eureka에 등록되는 status 값
  client:
    fetch-registry: true
    register-with-eureka: true
    service-url:
      defaultZone: http://<유레카 public ip>:8761/eureka/

ec2 4개에 각 Server , Consumer1 , Consumer2 , Producer1 올리고 모니터링

서로 다른 서버의 메소드 호출!

• User

  @Component
  public class DifferentClientLogicConsumer {
  
    @Autowired
    private DiscoveryClient client;
  
    public String getClient1ServiceLogic() {
        //해당 이름으로 등록된 spring cloud 앱들 반환
        List<ServiceInstance> siList = client.getInstances("PRODUCER-SERVICE");
  
        //PRODUCER-SERVICE 로 등록된 기능의 spring cloud client 앱객체
        ServiceInstance si = siList.get(0);
  
        //PRODUCER-SERVICE
        System.out.println("User  요청 처리 " + si);
  
        String url = si.getUri() + "/secondclient";
        System.out.println(url);
        RestTemplate rt = new RestTemplate();
  
        String response = rt.getForObject(url, String.class);
        return response;
    }
  }

  @Slf4j
  @RestController
  public class ThirdClientController {
  
    @Autowired
    private DifferentClientLogicConsumer consumer; 
  
    //http://localhost:<>/secondclient
    @GetMapping("/user")
    public String first() {
        System.out.println("Consumer2의 first() (Get/user) 메소드 ***");
  
        return "Consumer 응답 데이터 " + consumer.getClient1ServiceLogic();
    }
  

}

- producer
```java
    //http://localhost:9009/secondclient
    @GetMapping("/secondclient")
    public String second() {
        System.out.println("Producer의 first() 메소드 호출 ***");
        return "알레스카 사는 김상덕씨";
    }

producer port (9009) , User port (8090)

하지만 user에서 producer의 메소드를 부르고 있음!

두 개의 Stack(key, delete)을 사용하여 풀이하였다. 이유는 두가지이다.

'-' : keyStack에 가장 최근에 들어간 문자열을 삭제해줘야함. (LIFO) '<' or '>' : 커서 위치 변경은 삽입 순서가 바뀌는 것이다. '<'을 할 때 left에 가장 최근에 들어간 문자열을 right에 저장해준다. '>'을 할 때는 right 있는 문자열을 꺼내준다음 left에 넣어준다.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;

public class Main {
    static int T;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        T = Integer.parseInt(br.readLine());

        for (int t = 0; t < T; t++) {
            String str = br.readLine();
            Stack<Character> left = new Stack<>();
            Stack<Character> right = new Stack<>();

            for (int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);

                switch (c) {
                    case '<':
                        if (!left.isEmpty()) {
                            right.push(left.pop());
                        }
                        break;
                    case '>':
                        if (!right.isEmpty()) {
                            left.push(right.pop());
                        }
                        break;
                    case '-':
                        if (!left.isEmpty()) {
                            left.pop();
                        }
                        break;
                    default:
                        left.push(c);
                        break;
                }
            }

            StringBuilder sb = new StringBuilder();
            while (!left.isEmpty()) {
                right.push(left.pop());
            }
            while (!right.isEmpty()) {
                sb.append(right.pop());
            }

            System.out.println(sb);
        }
    }
}

🥲 dfs 조합으로 풀이시 시간초과 발생 !

public class Song3273 {
    static int N;
    static int[] arr;
    static int X;
    static int ans;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        N = Integer.parseInt(br.readLine());
        arr = new int[N];

        StringTokenizer st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }
        X = Integer.parseInt(br.readLine());

        findCombinations(0, 0, 0);
        System.out.println(ans);
    }

    private static void findCombinations(int idx, int selectedCount, int currentSum) {
        // 종료 조건
        if (selectedCount == 2) {
            if (currentSum == X) {
                ans++;
            }
            return;
        }

        // 조합 생성
        for (int i = idx; i < N; i++) {
            findCombinations(i + 1, selectedCount + 1, currentSum + arr[i]);
        }
    }
}

주어진 코드는 모든 가능한 조합을 DFS를 통해 생성하고, 합이 X인 경우를 찾아내는 방식으로 문제를 해결하려고 합니다. 그러나 이러한 방식은 입력의 크기가 커질수록 시간 복잡도가 급격하게 증가하게 되어 시간 초과가 발생할 수 있습니다.

빅 오 표기법에서 이 코드의 시간 복잡도를 나타내면 O(2^N)이 됩니다. 여기서 N은 배열의 크기를 의미.

백준 3273번 문제에서 주어진 입력 범위에 대해 고려해보면, N이 최대 10,000까지 가능합니다. 따라서 O(2^N)의 시간 복잡도는 매우 큰 값이 되어 효율적으로 해결하기 어려워집니다.

풀이

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Song3273 {
    static int N;
    static int[] arr;
    static int X;
    static int ans;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        N = Integer.parseInt(br.readLine());
        arr = new int[N];

        StringTokenizer st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }
        X = Integer.parseInt(br.readLine());

        Arrays.sort(arr); // 정렬!

        int left = 0, right = N - 1;

        while (left < right) {
            int sum = arr[left] + arr[right];

            if (sum == X) {
                ans++;
                left++;
                right--;
            } else if (sum < X) {
                left++;
            } else {
                right--;
            }
        }


        System.out.println(ans);
    }



}

📑 새로운 추가될 가능, 개선 해야할 가능, 버그 등등 모든것이 이슈! 팀 프로젝트에서는 모든 활동 내역에 대해서 이슈를 등록하고 그 이슈기반으로 작업을 진행하게 된다. 이슈를 등록할 때 자주 사용하는 템플릿을 등록해서 사용하는 방법이 효율적

1. 레포지토리의 Settings로 들어간다.

2. General 탭에서 아래로 내려보면 Features > Issues 에서 Set up templates 버튼을 클릭

3. 이슈 템플릿 생성

컨텐츠 내용을 작성하고 default title 을 줄 수 있음! 이슈 생성시 이름 앞에 [FEAT] 붙이는 설정 ex) [FEAT] 로그인 기능 구현

4. 템플릿으로 이슈 작성

Projects 와 Milestone 은 미리 등록해놓아야 설정 가능함 이슈를 만들면 이슈 번호가 주어짐!

🏂 Project(칸반보드) 생성

Organizations 이나 개인의 프로젝트를 나타냄

2023-shook 프로젝트의 칸반보드를 make copy 해서 개인 칸반보드를 생성 아까 만든 이슈에서 칸반보드 설정을 넣어주어 표시되도록 함

🪨 Milestone 생성

마일드스톤은 프로젝트 이슈 탭에서 생성가능

마일스톤으로 등록하면 관련 이슈와 진행도를 한 눈에 확인이 가능! 보통 큰 작업 개념이나 version 을 등록 아까 생성한 이슈에서 마일드스톤 설정을 넣어주어 표시되도록 함

✚ 이슈 하나더 생성

생성 후 이슈 Status 설정가능

👨‍🔬 하나의 마일드스톤(큰 작업)에 두개의 이슈 생성 완료

👍 일반적으로 개발 프로세스에서 각각의 이슈에 대해 별도의 브랜치를 생성하여 작업하는 것이 일반적임! 작업 흐름:

1. 이슈를 선택하고 해당 이슈 번호로 새로운 브랜치를 생성. ex) feat/{issue-number}-{feature-name} feature/#123-implement-new-feature
2. 해당 브랜치에서 작업을 수행하고 변경사항을 커밋.
3. 작업이 완료되면 원격 저장소로 push하고, 이슈에 대한 작업이 끝났음을 나타내기 위해 pull request를 생성.
4. pull request는 코드 리뷰와 테스트를 거쳐 메인 브랜치에 병합.

🕊️ IntelliJ Task로 Issue 브렌치 생성하기

😁 인텔리제이에서는 레포지토리에 존재하는 이슈로 브랜치를 생성하는 기능을 제공하고 있음.

1. IntelliJ - Tasks 연동

인텔리제이의 Preferences 를 들어간 후 Tools > Tasks > Server에서 + 버튼을 누르고 Github 와 연동 , 정보를 입력하고 토큰을 발행해야함

2. 브렌치 생성

원래는 Dev 브렌치에서 파야하지만 Main을 Dev라고 가정하고 진행 인텔리제이 우상단 Default task 영역을 클릭 후, Open Task...를 클릭하면 아까 만들어 놓은 이슈를 확인가능! (프로젝트이름)-(이슈번호):(이슈이름) 브랜치명(Create branch)을 명명 규칙에 맞게 수정하고 OK버튼을 클릭 Default Task는 위에서 Create changelist에 등록한 이름으로 바뀌었고 terminal 에서 브렌치 생성 확인 가능

🫸 인텔리제이에서 커밋, 푸쉬

feat/#1-이슈테스트1 브렌치에서 2개의 커밋을 만들고 push 해줌

1. 오른쪽 하단에서 내 현재 브렌치 확인❗️
2. ~ 작업 ~
3. 왼쪽의 상단 세로의 Commit 버튼을 누르고 커밋. (Commit and Push 하여 Remote에도 바로 적용가능) 깃허브에서도 확인가능 사실 커밋 메세지도 아래와 같이 컨벤션을 맞춰줘야함 , 여기서는 그냥 테스트진행

   Feat: "Add login API"        // 타입: 제목
   

로그인 API 개발 // 본문

Resolves: #123 // 꼬리말 => 이슈 123을 해결했으며, Ref: #456 이슈 456 를 참고해야하며, Related to: #48, #45 현재 커밋에서 아직 이슈 48 과 45 가 해결되지 않았다.

## 📤 Pull request 생성
PR 템블릿은 따로 생성 해줘야함
참고 : [Github - Pull request template 작성과 설정](https://green-bin.tistory.com/16)

Github에서 PR 탭 클릭하여 PR생성
_**🤬 브렌치가 어디서 어디로 합쳐지는지 꼭 잘 확인해야함!!**_
![](https://velog.velcdn.com/images/dumbveloper_100/post/dc7c8c94-b498-4b2f-a567-29e01ac274d4/image.png)

![](https://velog.velcdn.com/images/dumbveloper_100/post/1afa7b74-c340-49ff-a6e3-ae27c1e11ec6/image.png)
PR도 이슈처럼 내용을 작성해주고 Assigners, labels, projects, milestone 를 넣어줄 수 있음 + Reviewer
연관된 이슈 번호를 입력하여 추적 가능

#### PR을 받은 사람은 해당 브렌치의 커밋 코드 및 컨벤션을 점검하고 Merge함 , Merge 후에는 브렌치를 삭제 할 수 있음
![](https://velog.velcdn.com/images/dumbveloper_100/post/c0dcc3e9-c2e0-4754-9d9c-8c0df60a4e65/image.png)
프로젝트 칸반보드에서도 확인가능
![](https://velog.velcdn.com/images/dumbveloper_100/post/d78c2726-2d0d-468d-b594-c21f8b6c34b9/image.png)

1. Project Settings에서 SDK를 17 버전으로 맞춤

2. IntelliJ Settings 에서 Gradle JVM 버전을 맞춰줌

참고 : https://jojoldu.tistory.com/698

풀이

입력에 주어진 치킨집을 M개로 줄일때 최소 도시의 치킨거리 (집-치킨집 거리의 최소값들의 합) 을 구하는 문제

• 조합 combination (dfs)

• 최소거리의 합의 최소를 구하는 문제! 👉 어떤 치킨집이 없어지지 않고 선택되어 남아있는지에 따라 거리가 달라짐

  • 특정 집 - 치킨집의 최소 거리를 구해야함 (치킨거리)
  • 치킨거리 합의 최소값을 구해야함 (도시의 치킨거리)

import java.io.*;
import java.util.*;

public class Main {
    static int N, M;
    static int ans = Integer.MAX_VALUE;
    static int[][] map;
    static boolean[] selected;
    static class Chicken{
        int x, y;
        public Chicken(int x, int y){
            this.x = x;
            this.y = y;
        }
    }
    static class House{
        int x, y;
        public House(int x, int y){
            this.x = x;
            this.y = y;
        }
    }
    static ArrayList<Chicken> chickens = new ArrayList<>();
    static ArrayList<House> houses = new ArrayList<>();

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        map = new int[N][N];

        for(int i = 0; i < N; i++){
            st = new StringTokenizer(br.readLine());
            for(int j = 0; j < N; j++){
                int n = Integer.parseInt(st.nextToken());
                map[i][j] = n;
                if(n == 1){
                    houses.add(new House(i, j));
                }
                if(n == 2){
                    chickens.add(new Chicken(i, j));
                }
            }
        }

        selected = new boolean[chickens.size()];
        dfs(0,0);
        System.out.print(ans);
    }

    static void dfs(int idx, int cnt){
        if(cnt == M){
            ans = Math.min(ans,distance());
            return;
        }

        for(int i = idx; i < chickens.size(); i++){

            if (selected[i]) continue;

            selected[i] = true;
            dfs(i + 1, cnt + 1);

            selected[i] = false;
        }
    }

    static int distance(){
        int sum = 0;
        for (House house : houses) {
            int min = Integer.MAX_VALUE;
            for (int i = 0; i < chickens.size(); i++) {
                if (selected[i]) {
                    Chicken chicken = chickens.get(i);
                    int d = Math.abs(house.x - chicken.x) + Math.abs(house.y - chicken.y);
                    min = Math.min(min, d);
                }
            }
            sum += min;
        }
        return sum;
    }
}

자체 데이터 센터에서 운영하는 기존 네트워크와 유사한 가상의 네트워크를 의미. 우리는 AWS VPC를 사용하여 논리적으로 격리된 가상 네트워크를 구성하고 그 네트워크 안에서 AWS 리소스를 사용할 수 있게 되는 것!

Ipv4 CIDR 블록

💡10.0.0.0/16 으로 생성 -> 10.0.0.0 ~ 10.0.255.255 IP 주소 범위를 가지게 된다는 것을 의미 VPC의 네트워크 주소: 10.0.0.0 최소 호스트 주소: 10.0.0.1 최대 호스트 주소: 10.0.255.254 브로드캐스트 주소: 10.0.255.255 👉 VPC 내에서 여러 서브넷을 생성하거나 다양한 리소스에 IP 주소를 할당할 수 있으며, 10.0.0.1부터 10.0.255.254까지의 주소 범위에서 가능!

테넌시

VPC 리소스의 전용 하드웨어에서의 실행 여부를 뜻 하드웨어가 공유 하드웨어를 사용할 것인지 혹은 전용 하드웨어를 사용할 것인지를 선택하는 항목 전용을 선택할 경우 VPC 내의 인스턴스는 항상 전용 하드웨어에서 전용 인스턴스로 실행되며 별도 비용이 추가되게 됨!

📍 가용영역

가용 영역(Availability Zone)이란 AWS 하나의 리전 내에 중복 전원, 네트워킹 및 연결이 있는 하나 이상의 개별 데이터 센터를 의미. 여러 AZ를 사용하면 높은 가용성과 내결함성 및 확장성을 갖출 수 있게 되며, 가용영역이 다르면 독립되었음을 보장할 수 있으므로 가용 영역별로 서브넷을 제공하면 여러 서브넷을 동시에 이용하지 못하는 가능성을 낮출 수 있다.

2. 서브넷 생성

서브넷 4개 (private 2개, public 2개) 생성

2-1.서브넷을 생성할 VPC선택

2-2.서브넷 설정 선택

Ipv4 서브넷 CIDR 블록

💡10.0.1.0/24 으로 생성 -> 10.0.1.0 ~ 10.0.1.255 IP 주소 범위를 가지게 된다는 것을 의미

public1,2 와 private1,2 를 10.0.1.0/24 ~ 10.0.1.4/24 로 생성 public1 , private1 는 ap-northeast-2a public2 , private2 는 ap-northeast-2c

2-3. VPC의 리소스 맵에서 생성확인

• nternet gateway 추가 설정해야만 네트워크와 인터넷 사이의 통신이 가능
• igt 생략시 VPC 내의 리소스는 서로 통신 불가

3. 인터넷 게이트웨이 (IGT) 생성

VPC 에서 생성된 네트워크와 인터넷 사이의 통신 수행

3-1. VPC 하위의 인터넷 게이트웨이 선택 후 게이트웨이 생성

3-2. VPC 와 연결

작업에서 VPC 연결을 설정해주고 Attached 상태가 되는것을 확인

4. NAT(Network Address Translation) 설정

public 1, 2 에 NAT 게이트 웨이 설정

5. 라우팅 테이블 설정

subnet 사이의 통신 경로 설정을 위한 요소, 특정 서버에 접속할 때 꼭 경유해야 할 정보 보유, 모든 서브넷에 라우팅 table 작성해야 함! 속한 테이블

5-1. Public 라우팅 테이블 생성

vpc 를 선택하여 생성하고 라우팅 편집

로컬 라우팅 (Local Route) 10.0.0.0/16

• 대상(Target): VPC의 CIDR 블록 (예: 10.0.0.0/16)
• VPC 내부의 로컬 트래픽을 처리.
• 모든 VPC 내부 통신은 VPC의 CIDR 블록을 통해 이 라우트에 의해 처리되는 것을 의미

  인터넷 라우팅 (Internet Route) 0.0.0.0/0

• 대상(Target): 인터넷 게이트웨이의 ID 또는 인터넷 게이트웨이 자체
• 인터넷으로 나가는 트래픽을 처리.
• 대상이 "0.0.0.0/0"이므로, 모든 목적지로 가는 트래픽은 이 라우트를 통해 인터넷 게이트웨이로 전달되는 것을 의미.

5-2. 서브넷 연결 선택 → 서브넷 연결 편집 → public subnet 두개 선택 저장

5-3. Private 라우팅 테이블 생성

NAT 게이트웨이 라우팅 (NAT Gateway Route):

• 대상(Target): NAT 게이트웨이의 ID 또는 NAT 게이트웨이 자체
• 프라이빗 서브넷에 있는 인스턴스들이 외부로 나가기 위해 사용하는 라우팅 규칙. 대상이 "0.0.0.0/0"이므로, 모든 목적지로 가는 트래픽은 이 라우트를 통해 NAT 게이트웨이로 전달

  VPC 리소스맵 구조

  

6. 보안 그룹 생성

• 점프 서버용 보안 그룹 (퍼블릿 서브넷에 위치) 인바운드 규칙 SSH -> 소스 : 0.0.0.0/0 SSH는 원격으로 서버에 접속하기 위한 프로토콜로, 보통 시스템 관리 작업 등을 수행하기 위해 사용
• 로드 밸런서용 보안 그룹 유형 : HTTP -> 소스 : 0.0.0.0/0 유형 : HTTPS -> 소스 : 0.0.0.0/0 HTTP는 웹 서버와 웹 클라이언트 간에 데이터를 전송

퍼블릭 서브넷: 점프 서버 (Bastion Host)가 위치하는 서브넷. 외부에서 SSH와 같은 프로토콜을 이용하여 이 서버에 접속할 수 있음.

프라이빗 서브넷: 보안상의 이유로 직접 외부로 노출되지 않는 서브넷. 실제 웹 서버, 데이터베이스 서버 등이 위치할 수 있음.

7. 점프 서버용 EC2 생성

EC2 인스턴스 생성시 VPC, 서브넷, 보안 그룹 설정 가능

퍼블릭 클라우드 vs 프라이빗 클라우드

🗂퍼블릭 클라우드

• 퍼블릭 클라우드는 공유 클라우드 인프라.
• 클라우드 벤더의 여러 고객은 데이터는 공유되지 않지만, 동일한 인프라에 액세스. ex) 레스토랑의 모든 사람이 동일한 주방에서 주문하지만, 다른 요리가 서빙되는 것과 같음.
• 퍼블릭 클라우드 서비스 공급자에는 AWS, Google Cloud Platform, Microsoft Azure ...

  "다중 테넌트" 란? 클라우드 공급업체의 여러 고객이 동일한 컴퓨팅 리소스를 사용하고 있음을 의미. 클라우드 고객은 리소스를 공유하기는 하지만, 서로를 인식하지 못하며 데이터가 완전히 분리.

  📂프라이빗 클라우드

• 단일 테넌트.
• 프라이빗 클라우드는 하나의 조직에 독점적으로 제공되는 클라우드 서비스.
• 가상 프라이빗 클라우드(VPC)는 퍼블릭 클라우드 내의 프라이빗 클라우드 다른 누구도 VPC 고객과 VPC를 공유하지 않음.

VPC가 퍼블릭 클라우드 내에서 어떻게 격리?

• 서브넷 : 네트워크 내의 모든 사람이 사용할 수 없도록 예약된 네트워크 내의 IP 주소 범위로, 기본적으로 개인 용도로 네트워크의 일부를 분할. VPC에서 서브넷은 공개적으로 볼 수 있는 일반적인 IP 주소와 달리 공개 인터넷을 통해 액세스할 수 없는 개인 IP 주소
• VLAN : LAN은 인터넷을 사용하지 않고 모두 서로 연결된 근거리 통신망 또는 컴퓨팅 장치 그룹. VLAN은 가상 LAN임. 서브넷과 마찬가지로 VLAN은 네트워크를 분할하는 방법
• VPN : 가상 사설망(VPN)은 암호화를 사용하여 공용 네트워크 위에 사설 네트워크를 만듬. VPN 트래픽은 라우터, 스위치 등 공개적으로 공유되는 인터넷 인프라를 통과하지만, 트래픽이 변환되어 누구에게도 표시되지 않음.

VPC에는 VPC 고객만 액세스할 수 있는 전용 서브넷과 VLAN이 있다! -> 퍼블릭 클라우드 내의 다른 사람이 VPC 내의 컴퓨팅 리소스에 액세스하는 것을 방지! ex) 테이블에 "예약석" 표시 -> VPC 고객은 VPN을 통해 VPC에 연결 즉, VPC 안팎으로 전달되는 데이터가 다른 퍼블릭 클라우드 사용자에게 표시되지 않는것.

VPC 와 서브넷

VPC (Virtual Private Cloud)

• 논리적으로 격리된 사용자 전용 가상 네트워크.
• 복수의 AZ (Availibity Zone, 가용영역 ≒ 데이터센터) 걸친 형태
• 💡 AWS의 리소스들이 위치할 네트워크 망.

  프로젝트에 사용되는 리소스 (EC2, RDS, S3 등등)이 물리적으로 하나의 데이터센터에만 위치해있다면 해당 센터에 문제가 생긴다면 서비스가 전체적으로 다운타임 발생!!! 👌 가상네트워크를 이용하여 물리적으로는 다른곳에 위치하지만 같은 사설망 IP 대역에 위치하게 만들어 리소스들끼리 통신할 수 있게 만들어주는 기술

서브넷 (subnet)

• VPC의 영역안에서 망을 더 쪼개는 행위
• 하지만 VPC와는 달리 지역적으로 나누기때문에 여러 AZ(가용영역)에 걸쳐있는것이 아닌 단일 AZ에 위치함.
• 대표적으로 보안과 네트워크의 브로드캐스트의 영역을 축소시켜서 통신 성능을 올리기 위함.

public 서브넷 , private 서브넷 나누기

Public Subnet

• 외부에서 접근이 가능한 네트워크영역
• 서브넷이 인터넷 게이트웨이로 향하는 라우팅이 있는 라우팅 테이블과 연결되는 경우 퍼블릭 서브넷이라 함.
  • 인터넷 게이트웨이(igw)는 VPC의 구성요소로써 VPC와 인터넷간에 통신을 할 수 있게 만들어주는 역할
  • 서브넷이 바라보는 라우팅테이블에 인터넷게이트웨이가 등록되어있는 것
• 해당 서브넷은 인터넷과 연결이 가능하므로 해당 서브넷에 위치한 리소스들은 공인IP를 가질 수 있음.

Private Subnet

• 외부에서 다이렉트로 접근이 불가능한 네트워크 영역
• 서브넷의 라우팅 테이블에 인터넷게이트웨이가 등록되어있지 않으므로 해당 서브넷에 위치한 리소스들은 외부와의 연결이 불가능

NAT (Network Address Translation)

• 프라이빗 서브넷에 DB가 있다고 가정하면, DB버전을 업그레이드하기위해서 인터넷 연결이 필요할 수 있음!

• 이때 NAT 게이트웨이를 이용하여, 내부에서 외부로만 접근이 가능하게 만들어 줄 수 있는 것.

• 외부에서 NAT 게이트웨이를 이용하여 접속을 불가능!!❌ 여기서 말하는 외부란, VPC영역이 다른것을 의미. 같은 VPC영역에 있으면 private IP로 접근이 가능!

NAT 게이트웨이 설정 방법

1. 퍼블릭 서브넷에 NAT 게이트웨이에 탄력적IP(EIP)를 할당하여 생성
2. 프라이빗 서브넷의 라우팅 테이블에 등록.

즉, 프라이빗 서브넷에서 라우팅 테이블을 보고 인터넷으로 나가는 규칙 (0.0.0.0)에 대해서는 NAT 게이트웨이를 타고 EIP(공인 IP)로 변환 후 igw를 통해 인터넷으로 나가는것입니다.

이렇게 불편해지는데 프라이빗 서브넷을 사용하는 이유는, 엄격하게 다뤄야할 리소스들을 안전하게 관리하기 위함.

앞서 예를든것처럼, DB를 프라이빗 서브넷에 위치시킨다던가, ELB(로드벨런싱)만 퍼블릭영역에 두고 실제 WAS는 프라이빗영역에 배치하여 보다 안전하게 관리할 수 있다~!

참고 https://dontbesatisfied.tistory.com/13

1. 버킷 생성

접근을 위해 퍼블릭 엑세스를 허용 해주자!

버킷 버전 관리를 활성화 할 경우 요금이 과금될 수 있음! IAM을 통해 만들어진 user 의 Access key ID,Secret access key 가 필요!

• 외부에 노출되지 않게 조심해야함!

버킷이 퍼블릭 엑세스 허용되도록 생성된 것을 확인

2. Spring 설정

build.gradle 추가

implementation 'org.springframework.cloud:spring-cloud-starter-aws:2.2.6.RELEASE'

yml 파일

server:
  port: 80    # server.port=80
  servlet:
    context-path: /probono  # server.servlet.context-path=/probono

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: '계정'
    password: '비번'
    url: jdbc:mysql://<엔드포인트>:3306/<데이터베이스>?useSSL=false&allowPublicKeyRetrieval=true

  jpa:
    database: mysql
    database-platform: org.hibernate.dialect.MySQL8Dialect
    generate-ddl: true
    hibernate:
      ddl-auto: none
    show-sql: true
  mvc:        # jsp 사용을 위한 필수 설정, WEB-INF 폴더 직접 만들고, pom.xml에 설정, ProbonoController의 메소드 setViewName()확인하기
    view:
      prefix: /WEB-INF/    # spring.mvc.view.prefix: /WEB-INF/
      suffix: .jsp         # spring.mvc.view.suffix: .jsp


  servlet:
    multipart:
      max-request-size: 30MB
      max-file-size: 30MB

cloud:
  aws:
    s3:
      bucket: <버킷이름>
    region:
      static: ap-northeast-2
    stack:
      auto: false
    credentials:
      access-key: <키>
      secret-key: <키>

중요한 정보가 담겨있음!! -> yml 파일은 절~대 github에 올리지 않도록 .gitignore를 꼭 설정해 주자

3. 간단한 사진 업로드 기능작성

config 파일

@Configuration
public class S3config {

    @Value("${cloud.aws.credentials.access-key}")
    private String accessKey;
    @Value("${cloud.aws.credentials.secret-key}")
    private String secretKey;
    @Value("${cloud.aws.region.static}")
    private String region;

    @Bean
    public AmazonS3Client amazonS3Client() {
        AWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);

        return (AmazonS3Client)AmazonS3ClientBuilder
            .standard()
            .withRegion(region)
            .withCredentials(new AWSStaticCredentialsProvider(credentials))
            .build();
    }
}

Service

@Service
@RequiredArgsConstructor
public class S3UploadService {

    private final AmazonS3 amazonS3;

    @Value("${cloud.aws.s3.bucket}")
    private String bucket;

    public String saveFile(MultipartFile multipartFile) throws IOException {
        String originalFilename = multipartFile.getOriginalFilename();

        ObjectMetadata metadata = new ObjectMetadata();
        metadata.setContentLength(multipartFile.getSize());
        metadata.setContentType(multipartFile.getContentType());

        amazonS3.putObject(bucket, originalFilename, multipartFile.getInputStream(), metadata);
        return amazonS3.getUrl(bucket, originalFilename).toString();
    }
}

Controller

@RestController
@RequiredArgsConstructor
public class FileUploadController {

    private final S3UploadService s3UploadService;

    @PostMapping("/api/upload")
    public ResponseEntity<String> upload(@RequestPart(name = "file") MultipartFile file) throws IOException {
        return ResponseEntity.ok(s3UploadService.saveFile(file));
    }

}

😢오류!

수정 전

@PostMapping("/api/upload")
    public ResponseEntity<String> upload(@RequestPart MultipartFile file) throws IOException {
        return ResponseEntity.ok(s3UploadService.saveFile(file));
    }


오류 발생
Request part name for argument type [org.springframework.web.multipart.MultipartFile] not specified, and parameter name information not found in class file either.

파라미터 이름 정보가 클래스 파일에서 찾을 수 없다는 에러가 발생한다!

메서드의 파라미터에 이름을 명시적으로 지정하여 해결해줬다.

수정 후

@PostMapping("/api/upload")
    public ResponseEntity<String> upload(@RequestPart(name = "file") MultipartFile file) throws IOException {
        return ResponseEntity.ok(s3UploadService.saveFile(file));
    }

postman으로 테스트

form-data에서 File 형식으로 설정하고 컨트롤러에서 설정한 parameter name 을 넣어 준다. 업로드할 사진을 넣고 send! 반환 값으로 업로드한 해당 사진의 url 값이 오게 됨

이제 이 url로 크롬에서 접속해 보면~?

이미지 확인이 가능하다~

구성

stress-ng: 시스템 리소스에 부하를 주는 리소스 스트레스 테스트 도구 --cpu 1: CPU 1개에 대한 부하 생성. --cpu-load 73: CPU 부하의 크기, 73%의 부하를 생성. --timeout 60s: 부하 테스트를 수행할 시간을 지정. --metrics: 실행 중에 발생하는 메트릭(성능 측정 지표)를 표시. 이를 통해 CPU 사용률, 메모리 사용 등을 모니터링.

CloudWatch

Amazon CloudWatch는 AWS 리소스와 AWS에서 실시간으로 실행 중인 애플리케이션을 모니터링 하는 서비스 입니다.

CloudWatch에서 대시보드 만들고 위젯추가 (CPU Utilization)

지표를 감시해 알림을 보내거나 임계값을 위반한 경우 모니터링 중인 리소스를 자동으로 변경하는 경보를 생성할 수 있습니다.

예를 들어 경보는 인스턴스 중지, auto scaling 및 Amazon SNS 작업 시작, 종료 등으로 구성할 수 있습니다.

경보 생성

경보 알림 메일을 빠르게 받아보기 위해 최대 , 1분 설정 조건 설정 , 임계값 50으로 이메일 주소 입력 임계치를 넘게되면 메일이 전송됨 !

메일 내용

Alarm Details:
- Name:                       12myec2CPU알림
- Description:                *************
12myec2CPU알림
*************
- State Change:               INSUFFICIENT_DATA -> ALARM
- Reason for State Change:    Threshold Crossed: 1 out of the last 1 datapoints [82.2033898305085 (28/02/24 02:38:00)] was greater than the threshold (50.0) (minimum 1 datapoint for OK -> ALARM transition).
- Timestamp:                  Wednesday 28 February, 2024 02:43:59 UTC
- AWS Account:                646580111040
- Alarm Arn:                  arn:aws:cloudwatch:ap:alarm:12myec2CPU알림