사람들은 왜 이것에 열망하는지? 무슨 장점이 있길래? 이와 반대되는 개념은 뭐가있는지? 이런걸 좀 알아보았다.

DDD란 - 도메인 주도 개발

• 1. 대규모 서비스의 복잡한 비즈니스 로직을 체계적이고 명확하게 표현하고 관리하기 위함.

-> 비즈니스 로직을 관리하기 위해 '도메인 모델' 을 중심으로 개발을 한다고 한다.

• 2. 비즈니스 전문가와 개발자가 동일한 언어로 소통하기 위함

-> 코드와 비즈니스 용어가 일치하도록 설계한다. 이때 사용하는 언어가 '유비쿼터스 언어' 라고 한다. (비즈니스 + 개발 공통 언어)

• 3. 도메인을 Bounded Context 로 분리하여 책임을 명확하게 한다.

주문관리 와 재고관리 가 서로의 로직에 영향을 주지 않게 '독립성'을 보장한다.

• 4. 레이어드 아키텍쳐 ( 도메인레이어 + 애플리케이션레이어 + 인프라레이어 ) 로 구성되어서 도메인 로직을 명확하게 구분하여 관리한다.

명확하게 분리가 잘 되어있으면 부분적인 수정이 시스템에 영향을 미치지 않는다. 코드 변경시 리스크 감소

• 5. 단위 테스트 용이성

도메인 로직이 분리되어있기 때문에 테스트하기에 무척 용이하다고 한다.

결국 DDD 란

도메인 (주문, 재고관리, 배송, ...)에서의 규칙을 정해놓은 부분을 도메인이라고 하고 이 도메인을 객체지향적(확장성+유지보수성)으로 개발하는 방법론이다.

TS란 - 트랜잭션 스크립트

트랜잭션 스크립트는 DDD와 거의 반대되는 개발 방법론이다. (다른것이지 틀린건 아님)

절차 중심적인 설계를 한다.

DDD와의 차이점

TS는

1. 절차지향적이다.

2. 데이터를 직접 조작하며 비즈니스 로직이 코드에 그대로 들어가있다.

3. 코드의 흐름이 명확하게 짜여져있어서 이해하기가 쉽다.

4. 작은 규모의 프로젝트에 적합하다.

하지만 이러한 점들에는 한계점이 있는데

코드의 중복이 많이 생긴다는 것.

그리고 코드 한 부분을 수정하면 다른 부분까지 수정해야 하는 경우가 자주 생김

아직은 개념적인 부분에 대해서 접근하고 있고 조금씩 넓혀나갈 생각이다.

그냥 서비스 하나 만들었으면 Postman으로 쭉 테스트 해보면 되는거 아닌가?

라고 생각했다.

하지만 테스트코드의 장점은 이 뿐 만이 아니다.

만약 이전에 완성했던 코드를 수정했을 때, 또 다시 모든 경우를 하나하나 직접 테스트 해봐야 한다.

Postman 테스트는 사람이 직접 하는거다 보니 실수가 생길 수 있다. 이런 경우를 대비하여 테스트코드를 작성해두고 발생할 수 있는 문제의 경우의 수를 코드로 작성해 두는 것이다.

JUnit5

• JUnit 5는 Java 애플리케이션에서 단위 테스트(Unit Test)를 수행하기 위해 사용되는 테스트 프레임워크

모듈화 구조로 인한 유연성

• JUnit 5는 크게 3개의 모듈로 구성됩니다:

  • JUnit Platform: 테스트 실행 및 결과 보고 (테스트 실행 환경)
  • JUnit Jupiter: JUnit 5의 핵심 모듈, 실제 테스트 작성 (테스트 시 사용되는 대부분의 모듈들) ex) @Test, @BeforeEach, @AfterEach, @Nested, @DisplayName
  • JUnit Vintage: JUnit 4와 호환성을 제공

  JUnit5을 통해 만들어진 테스트 환경속에서 테스트를 진행하게 된다.

AssertJ

AssertJ를 통해 내 테스트코드를 검증하자.

JUnit5 에도 Assertions 클래스가 제공 된다. 하지만 AssertJ를 따로 추가해서 사용하는것이 더 가독성이 좋다. AssertJ는 함수형 프로그래밍 패러다임으로 만들어졌기 때문이다.

• JUnit5의 Assertions

    @Test
    void testEquals() {
        String actual = "Hello";
        String expected = "Hello";
        assertEquals(expected, actual);
    }

• AssertJ

    @Test
    void testEquals() {
        String actual = "Hello";
        assertThat(actual).isEqualTo("Hello");
    }

무엇을 검사할지 명확하게 지정하고, 검사 방법까지 다음 메서드로 호출하기 때문에 차례대로 읽기가 쉽다.

Mockito

단위 테스트를 위해서 사용되는 mock 객체 라이브러리이다. 가짜 객체를 만들어주는 역할을 한다.

1. 텅 빈 가짜 객체를 만들어 주고(의존성 주입) 테스트 할 코드를 실행하는데 문제가 없도록 만들어 준다.

2. mock 객체 내부의 메서드를 사용해야 한다면 정의를 해줘야 사용이 가능하다. ('파라미터는 무엇이고' 그 파라미터가 들어왔을 때 , '어떤걸 반환한다 혹은 throw 한다')

3. 해당 테스트에서 mock 객체를 만들어두고 사용되지 않는다면 이것또한 찾아준다.

4. 메서드 호출 횟수를 검증할 수 있다.

        @Test
        public void 정상동작의_경우() {

            // given: Mock 객체 생성, 테스트 해볼 동작을 설정
            User mockAdminUser= User.builder()
                    .id(1L)
                    .authCode("adminUser authCode")
                    .role(User.Role.ROLE_ADMIN)
                    .email("admin@google.com")
                    .type(OAuth2Type.GOOGLE)
                    .nickname("운영자")
                    .password("admin password")
                    .registerDate(LocalDateTime.now())
                    .build();

            BoardNotice mockNotice = BoardNotice.builder()
                    .id(1L)
                    .title("notice Write title")
                    .content("notice Write content")
                    .views(123)
                    .type(BoardType.NOTICE)
                    .thumbnail("thumbnail url")
                    .status(BoardStatus.PUBLISHED)
                    .user(mockAdminUser)
                    .createdAt(LocalDateTime.now())
                    .publishedAt(LocalDateTime.now())
                    .updatedAt(null)
                    .deletedAt(null)
                    .imageToken("notice image token")
                    .build();


            Long noticeId = 1L;

            BoardAdminRequest.Notice request = new BoardAdminRequest.Notice();
            request.setTitle("title");
            request.setBoardType("NOTICE");
            request.setImageSrc(List.of("img1", "img2"));
            request.setThumbnail("thumbnail");
            request.setContent("content");
            request.setImageToken("imageToken");

            AuthUser mockAuthUser = new AuthUser(new UserDto(mockAdminUser.getId(), mockAdminUser.getEmail(), mockAdminUser.getNickname(), mockAdminUser.getAuthCode(), mockAdminUser.getRegisterDate(), mockAdminUser.getType(), mockAdminUser.getRole()));

            when(userRepository.findById(any(Long.class))).thenReturn(Optional.of(mockAdminUser));
            when(noticeBoardRepository.save(any(BoardNotice.class))).thenAnswer(invocation ->
            {
                BoardNotice boardNotice = invocation.getArgument(0);

                try {
                    Field idField = BoardNotice.class.getDeclaredField("id");
                    idField.setAccessible(true);
                    idField.set(boardNotice, noticeId);
                } catch (NoSuchFieldException | IllegalAccessException e) {
                    throw new RuntimeException("필드 수정 오류", e);
                }

                return boardNotice;
            });
            when(boardNoticeMapper.toNewNoticeId(any(Long.class)))
                    .thenReturn(new BoardAdminResponse.newNotice(mockNotice.getId()));

            // when: 실제 테스트 하고싶은 메서드
            BoardAdminResponse.newNotice result = boardAdminService.writeNotice000(request, mockAuthUser);

            // then: 테스트 메서드 동작 후 검증 단계
            assertThat(result).isNotNull();
            assertThat(result.getNoticeId()).isEqualTo(mockNotice.getId());

            verify(userRepository).findById(mockAuthUser.getUserDto().id());
            verify(boardImageService).checkAndSave(eq(request.getImageSrc()), eq(request.getImageToken()));
            verify(boardNoticeMapper).toNewNoticeId(mockNotice.getId());

        }

테스트 코드는 given, when, then 으로 나누어서 작성하는 방식을 따른다.

'given' 에서는 테스트 환경에 필요한 사전 구성 작업이다. 여기서 mock 객체에 대한 설정들을 해주고 mock 내부 메서드를 사용한다면 채워줘야 한다.

'when' 에서는 우리가 만들어놓은 가상의 환경에서 테스트 하고싶은 메서드를 실행한다.

'then' 에서는 테스트 후 결과를 검증하는 단계이다. 위 코드에서는 assertThat(AssertJ) 이랑 verify(Mockito)를 통해서 검증하고 있다.

assertThat은 값을 직접 확인하고, verify 는 메서드 호출(몇번 호출했는지, 어떤 인자가 들어갔는지)에 대한 검증을 한다.

05.15 추가)

테스트코드를 작성하면서 spy 객체라는것을 접하게 되었다. (사용하지는 않았음.)

spy

java 에서 primitive 타입으로 int, long 이런것들이 있다. 이러한 값들을 하나의 객체로서 사용하기 위해서 우리는 Wrapper 클래스를 통해 각 primitive 값들을 감싸서 객체로 사용할 수 있게 된다.

여기서 마치 Wrapper 클래스와 비슷한 역할을 한다. spy는 우리가 만든 '실제 객체'를 감싸서 'mock 객체' 로 만들어 주는 역할을 한다. 이러한 짓을 왜하는거지? 싶지만

실제 객체의 대부분의 기능을 사용하고 싶은데 하나의 기능만 mocking 해서 사용하고 싶을때

즉 실제 객체의 부분적인 mocking 이 필요할 때 사용한다.

내가 spy를 사용하게 된 경위는 아직 테스트코드에 대해서 익숙하지 않아서였다.

mockito 에서 제공하는 verify 라는 메서드가 있다.

이는 'mock 객체'의 특정 메서드가

1. 호출 되었는지?
2. 몇 회 호출 되었는지?
3. 호출 시 특정 파라미터로 호출 되었는지?

를 확인할 수 있다.

왜 안쓰는거야

verify 메서드를 실제 객체를 대상으로 사용하려고 했고 에러가 발생했다.

그래서 이를 해결하기 위해 단순히 spy로 감싸서 사용했지만

엔티티 즉 POJO 객체(순수한 도메인 로직)에는 spy를 사용하지 않는것이 원칙이다.

굳이 해당 객체를 spy로 감싸지 않고도 검증할 수 있기 때문이다.

-> 무조건! 꼭! 내가 verify를 통해서 메서드 호출 횟수와, 파라미터를 검증해야겠다~ 고 한다면 spy로 감싸서 확인할 수 있다.

하지만 테스트 코드에서 중요하다고 생각하는건 쓸데없는 모킹, 쓸데없는 검증 은 지양해야한다.

안그래도 많은 mocking 과정이 필요한데 검증하지 않아도 되는 검증까지 해버리는 코드가 들어간다면 코드를 읽는데도 어려울게 당연하기 때문

결론: 내가 이 코드에서 정확하게 이것을 검증해야 한다. 라는 것을 명확히 하고 테스트 코드를 작성할 필요가 있다.

테스트코드를 작성안하면 불안에 떠는 개발자들이 많다고 하더라...

나는 여태껏 테스트코드를 많이 안써봤지만 앞으로 꼼꼼하게 작성해봐야겠다.

끝!

개발 환경과 실제 운영 환경을 분리하여 운영하기 위해 ec2 인스턴스를 추가로 생성하여 기존의 환경을 옮겨야 한다.

기존 컨테이너를 그대로 옮기는건 큰 문제가 되지 않는다.

1. 어떤 ec2 인스턴스가 우리 서비스에 가장 적합한가?

2. 현재 운영중인 데이터베이스의 데이터들은 어떻게 옮길 것인가?

ec2 인스턴스 고르기

요금 문제로 ec2 프리티어를 자주 사용해서, 무료 인스턴스 생성은 이제 익숙하다.

하지만 실제 운영되는 서버에 사용될 인스턴스이기 때문에 신중하게 고를 필요가 있다.

ec2 인스턴스 비용 계산 사이트

체크해야 할 부분

1. ec2 서비스 지역 확인

-> 아시아 태평양(서울) 이랑 미국에 오하이오 처럼 ec2 지역마다 대여 가격이 다르다.

2. 비용 결제 방식 확인

-> 가장 중요한 '비용'에 대한 결제 방식을 고려한다. 3가지 방식을 소개하면

• 온디맨드: 대여한 스펙에 맞게, 사용한 시간 만큼 결제
• 컴퓨팅 절감형: 약정형 대여 (할인 많이 해줌), 도중에 인스턴스 스펙 변경시 제약이 없음(당연히 추가비용은 발생 가능함)
• EC2 인스턴스 절감형: 약정형 대여 (할인 많이 해줌), 도중 인스턴스 스펙 변경에 제약이 있을 수 있음(인스턴스 유형이 비슷한 것 끼리만 변경 가능)

3. 인스턴스 유형

-> 대여할 인스턴스의 스펙을 고려한다.

현재 ec2 인스턴스를 사용중이고, 서비스하고 있는 중이면 htop 명령어를 통해 실시간 서버 리소스 사용량을 확인할 수 있다.

인스턴스 스펙 3요소를 보면

• CPU 성능 -> 현재 서비스의 cpu 사용량에 대해서 확인을 해본다. cpu 코어 개수가 많아질수록 가격 상승폭이 높음.
  cpu 종류에 따라서 가격도 꽤 많이 차이난다. cpu 인스턴스들은 특정 문자들로 시작한다. cpu 시리즈 중에서 t 시리즈를 많이 고려했기 때문에 다른 시리즈는 좀 더 찾아보길 바란다.

1. t 시리즈
```
t 시리즈는 기본 성능은 낮다.
하지만 t 시리즈에는 '버스트' 라는 기능이 있다.

t 시리즈는 '크레딧' 이라는걸 cpu 사용량이 적을 때 계속 조금씩 쌓아둔다.
그러다가 cpu 사용량이 폭발적으로 늘어나는 순간이 오면 크레딧을 사용해서 성능 향상을 시킬수 있다.
t 시리즈 마다 cpu 사용량 기준이 되는 지점이 있는데 해당 지점을 넘게되면 '버스트'가 활성화 된다.

t1 : 초창기 버전이다. 현재 지원 x

t2 : cpu 사용량이 많아져서 크레딧을 전부 소비하게 되면 속도가 제한된다.
    -> cpu 사용량 10~20% 이상시 버스트, 크레딧 소진시 속도 제한 걸림

t3 : unlimited 옵션을 켜면 추가 요금을 발생시키지만 속도를 유지할 수 있다.
    -> cpu 사용량 20~30% 이상시 버스트, 크레딧 전부 소진해도 unlimited 옵션을 켜면 속도 유지 but 추가요금 발생

t4g : unlimited 옵션을 켜면 추가 요금을 발생시키지만 속도를 유지할 수 있다.
      'g' 가 붙었는데 g 는 아마존 자체 개발 인스턴스이고 그렇기에 '더 저렴하고 더 빠르다'라는 특징이 있음
      g가 붙은것들은 !!⭐ARM 기반의 인스턴스이다.⭐!!(ARM 기반의 프로세서와 내 운영 서비스가 호환하는지 잘 찾아보기)
    -> cpu 사용량 20~30% 이상시 버스트, 크레딧 전부 소진해도 unlimited 옵션을 켜면 속도 유지 but 추가요금 발생

```
2. c 시리즈
```
c 시리즈는 cpu에 최적화된 인스턴스 유형이다.

cpu 처리량이 많은 서버의 경우 c 시리즈로 시작하는 인스턴스를 사용하는게 좋다.

```
3. r 시리즈
```
r 시리즈는 메모리에 최적화된 인스턴스 유형이다.

메모리 속도가 빠르고 많은 용량이 필요할 경우 선택하게 된다.

```
4. i 시리즈
```
i 시리즈는 스토리지에 최적화된 인스턴스 유형이다.

읽고 쓰기가 많은 경우 저장장치의 읽고 쓰는 속도가 중요한데 읽고 쓰기 작업의 속도가 중요할 때 사용하는걸 추천한다.

```

• RAM 용량 -> 메모리 여유 공간을 확인한다. 평상시 메모리 사용량보다, 배포할 때 메모리 최대 사용량을 확인해보는게 좋다. 서버가 켜져있을 때 보다 컨테이너들을 만들면서 메모리 부족으로 터지는 경우가 많았다.

  
  

  -> 인스턴스 뒤에 small, medium, large, xlarge 이렇게 붙은건 메모리 용량마다 차이가 난다.

• 저장 용량 -> 인스턴스에 저장되는 데이터가 많다면 크게 잡아줘야겠지만 엄청 클 필요는 없는것 같다. 적당하게 30 ~ 50GB 으로 잡아서 사용중

  
  

  ->저장 용량이 많아질수록 당연히 가격이 상승하고, 또한 저장장치도 빠른걸 쓰면 그만큼 비용이 증가함

  
  

  또한 '스냅샷' 이라는 기능이 있는데 특정 주기마다 백업을 하는 기능이다. 이 기능을 사용하게 되면 추가 비용이 많이 발생하는것 같은데 그냥 자체로 백업을 하는게 맞다고 본다.

데이터베이스 마이그레이션

인스턴스를 골라서 생성하고 나서 compose.yml을 옮기거나 각종 설정들을 다 해준 후 실제 운영데이터들을 옮겨야 할 것이다.

MySQL

MySQL은 Data Exports를 해주면 된다.

보통 MySQL 쓸 때 cli 보다는 workbench를 많이 사용하는데

여기서 스키마 선택하고 Data Exports 해주면 dump 파일들이 생긴다.

이를 새로운 인스턴스에 접속해서 Data Import 해주면 끝

MongoDB

MySQL에서 스키마(DB) 라고 하는거를 MongoDB 에서는 그냥 DB 라고 하고 MySQL에서의 테이블을 MongoDB에는 Collection 라고한다. 또한 mysql의 튜플은 mongoDB에서 document 라고 한다.

그런데 중요한 점은 MySQL workbench에서는 DB exports 가 되어서 스키마 내부에 테이블들을 한번에 백업할 수 있다.

그런데 MongoDB 전용 툴인 MongoCompass 에서는 그게 안된다. 그래서 collection이 많다면 하나씩 옮기느라 시간이 오래걸릴 수 있다.

또한 각 DB 마다 '계정' 이 존재해서 이러한 정보들은 또 수동으로 옮겨줘야 한다.

나는 운영 mongo 안에 컬렉션이 너무 많아서 다른 방법을 찾았는데

컨테이너에 직접 접속해서 dump를 만들고 이를 밖으로 꺼내서 사용했다.

MongoDB 전체 DB dump 생성 후 복원

• 이전 서버에서 dump 파일 생성하기 (mongo컨테이너 내부에 저장됨)

docker exec -it mongo mongodump -u <계정ID> -p <계정PW> --authenticationDatabase admin --out /data/dump

• 컨테이너 내부 dump 파일을 컨테이너 밖에 복사 (docker cp 사용)

docker cp mongo:/data/dump ./dump

• FTP로 해당 dump 파일을 새로운 서버로 옮긴 후 dump파일을 mongoDB 컨테이너 안으로 복사

docker cp /home/ubuntu/dump mongo:/data/dump

• mongo 컨테이너 접속해서 mongorestore 하기

docker exec -it mongo mongorestore -u <계정ID> -p <계정PW> --authenticationDatabase admin /data/dump

이러한 과정을 거치게 되면 내부 데이터를 복제해서 옮기는 것이기 때문에 온전한 데이터 이전이 가능하다.

물론 옮기는 과정 중 발생하는 데이터는 유실되므로 서비스를 중지하고 옮겨야 한다.

이렇게 ec2 이전 작업을 해보았다.

끝

개발을 하다가 엔티티 내부에 연관관계로 매핑된 다른 엔티티를 불러올 때 column 값은 있지만 해당 데이터가 DB에서 없는 데이터일 경우 쿼리 단에서 예외가 발생한다. 이를 어떻게 해결해야 할까?

1. Board 에서 User의 엔티티를 들고있을 때

//Board 엔티티 내부 필드
    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "user_id")
    private User user;

Board 라는 엔티티 내부의 user 필드이다.

만약 user_id 가 null 인 값이 들어오면 어떻게 되나? (board 테이블에 한 튜플의 user_id 컬럼이 null 인 경우)

-> 이런 경우 FetchType.LAZY, EAGER에 관계없이 찾으려는 시도조차 안한다.

즉 user_id에 null 값이 들어있으면 그냥 Board만 딱 들고 온다는 것

그러면 user에는 null이 들어가있는다.

그리고 이는 optional 이라는 옵션이 true로 기본적으로 설정되어 있기 때문 (디폴트가 true라 안보임)

//Board 엔티티 내부 필드
    @ManyToOne(fetch = FetchType.EAGER, optional = true)
    @JoinColumn(name = "user_id")
    private User user;

핵심은 시도조차 안한다는 것 -> 쿼리가 안날아가니 문제될 게 없음.

위 경우에서 user에 접근하는 로직이 있다면?

당연히 NPE가 발생할 것이다.

그럼 필드를 Optional<User>로 만들어 주면 되겠네? -> X

Optional은 엔티티 필드에 쓰면 안된다고 한다. (JPA 스펙상 그렇다고 함, JPA에서 사용 금지함)

그럼 어떻게 하지...

서비스단에서 Optional로 가야 한다.

Optional<User> optionalUser = Optional.ofNullable(board.getUser());

이렇게 통하면 null-safe 하게 사용할 수 있다.

-> 하지만 나는 null 체크를 잘 해야한다는 설명을 하고있는게 아니다.

2. Board 내부 User id가 "존재할 때"

설명하고 싶은 상황은 이러한 상황이다.

1. Board 내부에는 User가 매핑되어 있다.
2. user_id pk 값으로 DB에서 찾게된다.
3. Board 테이블 내에는 user_id로 '10' 이라는 값이 존재한다.
4. User 테이블에서 pk 10을 가진 user는 없는 경우

일반적으로 구현할 때 유저가 회원 탈퇴를 하면 soft_delete를 한다.

"is_delete" 라는 컬럼을 User에 두고 삭제가 된다면 true 로 바꿔주는 그런식의 삭제 로직을 사용하는데

이러한 세부적인 정책은 결국 고객의 요구사항에 맞게 반영해야 하는 부분이기 때문에 달라질 수 있다.

그래서 해당 프로젝트에서는 회원 탈퇴 시 hard-delete 즉 데이터를 삭제하는 방향으로 구현하게 되었다.

Board 엔티티를 가져오면 fetchType에 따라 User를 바로 가져올 수도 있고, 아니면 필요할때 가져올 수 있다.

결국 User 엔티티를 조회하게 되는데 이 때 "user_id" 기반으로 찾을 수 없는 데이터라면???

-> SQL 에러가 발생한다.

이를 어떻게 해결했나?

@notfound(action = notfoundaction.ignore)

이는 JPA의 기능은 아니고 hibernate에서 지원하는 기능이다.

hibernate 공식문서 링크

//Board 엔티티 내부 필드
    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "user_id")
    @notfound(action = notfoundaction.ignore)
    private User user;

만약 user_id로 DB에서 검색을 했더니 데이터가 없는 데이터다? 그러면 예외를 발생시키지 말고 null을 넣어라

라는 어노테이션이다.

마치 Java Optional을 트랜잭션에 적용한 느낌이다.

나는 이런 어노테이션을 사용해서 예외 처리를 할 수 있었다.

1. Pageable이란

pageable은 Spring Data JPA 에서 목록을 불러올 때 쉽게 가져올 수 있도록 객체로 구현해 둔 클래스이다.

특정 게시판의 1) 몇 번째 페이지를 2) 몇 개 만큼 3) 어떤 기준으로 불러올 것인지를 결정할 수 있다.

또한 정렬 기준을 정할 수 있어서 다양한 게시판의 종류에 맞게 사용할 수 있다. (좋아요 100개 이상의 글, 가장 최신 글 등... )

2. 사용법

1.PageRequest

Pageable pageable = PageRequest.of(페이지번호, 한페이지에몇개);

Pageable pageable = PageRequest.of(페이지번호, 한페이지에몇개, 정렬조건);

Pageable을 사용하기 위해서는 PageRequest 객체를 통해 생성한다.

• 페이지 번호는 0 부터 시작하고 0이 첫번째 페이지이다.

• 페이지 당 몇개 는 원하는 개수만큼 불러올 수 있다.

• 마지막으로 정렬 조건은 Sort라는 객체를 통해 추가할 수 있다.

  
  

2. Sort

Sort는 흔히 SQL의 orderby의 역할을 한다.

Sort sort = Sort.by("createdAt");

이렇게 Sort를 만들었다면 정렬 기준은 페이지네이션 할 엔티티의 createdAt 필드의 오름차순으로 정렬하게 된다.

내림차순으로 하려면?

Sort sort = Sort.by(Sort.Direction.DESC, "createdAt");

혹은

Sort sort = Sort.by("createdAt").descending();

Sort sort = Sort.by("createdAt").descending().and(Sort.by("likes").descending());

이렇게 체이닝(Chaining) 방식을 통해 표현할 수 있다.

나는 아래의 방법을 자주 사용할 것 같다. ( 읽기 편하기 때문 )

Repository 에서는?

public interface BoardRepository extends JpaRepository<Board, Long> {

    Page<Board> findAll(Pageable pageable);
}

메서드에 Pageable을 넣어주고 원하는 객체 타입의 Page를 가져가면 된다!

-> 만약 추가적인 쿼리가 필요하다면?

    @Query("SELECT b FROM BOARD b WHERE b.status = :status")
    Page<Board> findAllByStatus(Pageable pageable, @Param("status") String status);

JPQL에 파라미터로 추가해주면 된다

이렇게 만들어진 Page<T> 객체는 어떻게 쓸 수 있을까?

일반적으로는 .getContent()를 통해서 '현재 페이지 목록' List를 가져올 수 있다.

해당 List는 무엇으로 이루어져있나?

Page에 받은 Entity 객체 타입이다. 즉 위 예시에서는 Board를 받아온다.

3. 활용

1. page 객체의 정보

page 객체에서 가져올 수 있는 정보는 다음과 같다.

page.getTotalElements();  => 전체 항목 수
page.getTotalPages();  => 전체 페이지 수
page.getNumber();  => 현재 페이지 번호
page.getSize();  => 한 페이지당 개수

이런 정보들을 넘겨주면 프론트에서 받아서 페이지네이션에 사용할 수 있다.

2. 무한스크롤

무한 스크롤은 프론트에서 요청할 때 다음 페이지에 대한 정보를 주면서 요청하는 것이다.

@Query("""
    SELECT b FROM Board b
    WHERE (:lastLikes IS NULL OR 
          (b.likes < :lastLikes OR (b.likes = :lastLikes AND b.id < :lastId)))
    ORDER BY b.likes DESC, b.id DESC
""")
List<Board> findNextPageByLikes(
    @Param("lastLikes") Integer lastLikes,
    @Param("lastId") Long lastId,
    Pageable pageable
);

좋아요 기준으로 무한스크롤을 한다고 하면 위와 같이 구현하게 된다.

중요한것은 프론트에서 다음 좋아요 개수(lastLikes)로 다음 페이지를 요청할 때, 분명 좋아요 개수가 겹치는 글들이 많을것이다.

이를 제대로 처리해주지 않으면 중복되는 글들이 섞여서 나오겠지?

그렇기 때문에 게시글 id를 받아와서 사용한다.

3. enum 클래스

미리 enum 클래스에 선언해놓고 가져다 쓰는 방식으로 사용할 수 있다.

이렇게 쓰면 매번 Sort를 만드는데 필드명을 직접 적을 필요가 없다. (오타 방지)

자주 쓰는 정렬 방식은 enum 클래스로 정의해두고 사용하면 좋다.

@Getter
@RequiredArgsConstructor
public enum BoardSort {

    // 인기순: 좋아요 내림차순, 동일한 좋아요 수면 최신순
    POPULAR(Sort.by("likes").descending().and(Sort.by("createdAt").descending())),

    // 최신순
    RECENT(Sort.by("createdAt").descending());

    private final Sort sort;
}

아래에서는 컨트롤러 부분인데 여기서 BoardSort가 enum 클래스이기 때문에 자동으로 valueOf() 가 동작해서 매핑한다.

orderby=POPULAR로 요청이 들어오면 orderby=BoardSort.valueOf("RECENT") 가 동작한다는 뜻

@GetMapping("/boards")
public ResponseEntity<List<BoardMetadata>> getBoardList(
    @RequestParam int pgno,
    @RequestParam int count,
    @RequestParam(defaultValue = "RECENT") BoardSort orderby
) {
    List<BoardMetadata> boards = boardService.getBoards(pgno, count, orderby.getSort());
    return ResponseEntity.ok(boards);
}

-끝-

HTTP 요청이 서버로 들어가면

Servlet Container 안에 Dispatcher Servlet이 받게 되는데

이 전에 들어오는 요청들은 필터에 걸러진다.

Spring Security는 이 필터에서 들어오는 요청이

안전한 요청인지, 인가 있는 요청인지 확인한다.

build.gradle 에 시큐리티 의존성을 등록을 해두면

이 프로젝트에 뭐 따로 해주지 않아도 알아서 전체 프로젝트에 적용이 된다.

프로젝트를 시작하면 아래처럼 비밀번호 알려주고 로그인을 하게 만듦

초기 ID 는 user, PW 는 사진에 나오는 랜덤으로 생성된 문자열이다.

그러면 로그인은 어떻게 할 수 있나?

1. 브라우저

   브라우저에서는 해당 서버의 주소로 들어가는데 경로는 /login 이다.

   로컬호스트에서 돌리는 경우는

   localhost:8080/api/login 이 되겠다. (context-path가 /api로 설정되어 있음)

   나는 컨트롤러에서 login을 매핑해주지 않았지만 시큐리티가 처음 설정되면 알아서 login 경로로 로그인할 수 있도록 만들어준다.

   • 접속 시 화면

1. Postman

   Postman으로도 로그인할 수 있다.

   • 요청 시 설정

나는 현재 서버에 테스트용으로 `/auth/main` 을 매핑해둔 상태이다. 여기에 요청을 보내기 전에 Authorization 탭에서 ‘Basic Auth’로 선택후 Username, Password 입력해둔다. 

여기서 왜 admin에 admin 이냐면 내가 application.yml 에 따로 설정해두었기 때문

```yaml
security:
  user:
    name: admin
    password: admin
```

Security Config

이 클래스를 만들어서 내가 원하는 곳에만 인증이 필요하도록 설정할 수 있다.

얘가 없으면 기본적으로 모든 요청은 인가작업이 필요하도록 설정되어있다.

우선 config 디렉토리에

SecurityConfig 클래스 만들어주고

@Configuration 과 @EnableWebSecurity 를 붙여준다.

1. @Configuration 은

해당 클래스는 스프링 앱에서 사용하는 설정파일입니다.

라고 선언해주는 기능이다.

1. @EnableWebSecurity 는

해당 클래스가 Security 설정을 해주는 클래스입니다.

라고 선언해주는것이다. 즉 Spring Security 설정파일로 만드는 어노테이션임

그런데 @EnableWebSecurity 안에는 @Configuration 이 포함되어 있다. (파고파고 들어가면 나옴)

근데 왜 또 붙이는거지?

→ 해당 클래스가 설정파일임을 알리기 위한 ‘관례’ 라고 한다.

그러니까 @Configuration 어노테이션이 붙어있으면 ‘일단 얘는 설정파일이다.’ 라고 개발자들에게 알려주는거다.

우리는

어떤 페이지는 로그인 안해도, 어떤페이지는 로그인 해야 볼 수 있게

‘커스텀 거름망’을 만드려면 SecurityFilterChain 이라는 것을 빈으로 등록해둬야 한다.

Spring Security는 ‘보안 필터 체인’ 이라는 것을 만들어야 한다.

*보안 필터 체인(Security Filter Chain)이란?

HTTP 요청이 들어오면 필터에 걸러져서 들어온다고 했다.

그 필터를 사슬처럼 엮어둔 것을 필터체인이라고 하고

이걸 Spring Security가 만들어준다.

근데 Security Config는 @Configuration이기 때문에 앱 시작 전 설정을 해 주는 클래스다.

그러면서 Security에 대한 설정을 만드는데 필요한 것이 SecurityFilterChain

그러기 위해서는 필터체인을 설정하는 해당 객체가 빈으로 등록되어 있어야 한다.

일단 간단하게 아래와 같이 SecurityFilterChian을 만들어봤다.

우리는 ‘커스텀 거름망’을 사용할 것이기 때문에

HttpSecurity 를 받아서 설정해주고 다시 리턴해주면 된다.

(return에 보면 build로 되어있다. SecurityFilterChain은 Builder 패턴을 사용하고 있음.)

대충 보면 requestMatchers랑 뒤에 뭐 붙어있는 형식이다.

1. requestMatchers 에는 적용할 context를 설정해줄 수 있다.

2. 그리고 그 뒤에는 접근 가능한 대상을 설정해주고 있다. (permitAll = 누구에게나 개방)

3. .anyRequest는? if else 문에서 else와 같다.

상당히 간단한 구조로 보인다.

• 이렇게 설정하면 /auth/main에 들어갈 수 있을까? → ( X )

안된다. /auth 안에 모든 경로에 접근가능하게 하려면 상대경로의 느낌으로 /* 을 붙여야 한다.

기본적인 Spring SecurityFilterChain 을 한번 만들어 봤다.

시작하기에 앞서

1. 나는 현재 docker-compose로 프론트 백 같이 빌드하고 있고,
2. nginx에서 사용할 default.conf 파일은 마운트 된 상태이다.
3. nginx는 컨테이너로 관리하고 있다.

아래의 4개를 신경써서 해야한다.

• 도커 볼륨 마운트
• nginx의 .conf 파일
• certbot 명령어
• crontab 설정

나는 이거 설정해주는데 몇 시간을 날렸는데 경로 설정, 명령어 경로 설정, 디렉토리 이름 설정 이런 부분에서 한 걸음 나갈때마다 막혔다...

webroot?

요약하자면, certbot을 계속 돌려둘 필요 없이 + 서비스의 중단 없이 ssl 인증을 자동으로 갱신할 수 있는 방법이다.

1. certbot 설치

sudo apt update
sudo apt install certbot

설치하고 확인하기

certbot --version

2. 인증서 받기 위한 설정

Let'sEncrypt가 도메인 소유권을 확인하기 위해서

http://muzip.store/.well-known/acme-challenge/

이 주소에 인증 파일이 있나 없나 확인한다.

webroot 방식은 해당 주소에 인증 파일을 올려서 검증받는 방식이다.

그렇기에 Let'sEncrypt에서 접속할 수 있도록 default.conf 설정을 아래와 같이 해준다.

server {
    listen 80;
    server_name example.com;

    location /.well-known/acme-challenge/ {
        root /var/www/certbot;
        allow all;
    }
}

여기서 경로 이름이 중요한지 모르겠지만 gpt는 /var/www/html 으로 하라고 했다가 /var/www/cerbot으로 하라고 했다가 그러길래 둘다 해봤는데 certbot으로 했을 때 동작했다.

경로가 영향을 미치는건지는 잘 모르겠음..

그다음

docker-compose.yml 에서 프론트 컨테이너(nginx)의 볼륨 마운트 부분이다.

위에서 사용한 경로와 리눅스 호스트에서 인증서 확인에 필요한 디렉토리를 연결을 해 줘야한다.

또한 여기서 /home/ubuntu/certbot-webroot 디렉토리 안에 .well-known/acme-challenge/ 이 디렉토리 까지 같이 만들어 놓는다

그 후에 chmod -R 755 /path/to/certbot-webroot로 권한 부여 까지 해주기

3. Certbot으로 인증서 발급

sudo certbot certonly --webroot -w /home/ubuntu/certbot-webroot -d muzip.store

여기서는 명령어를 잘 확인해야 한다.

-w 뒤에는 자신이 만들어둔 디렉토리로 설정해주고 -d 뒤에는 자신의 도메인을 넣어준다.

해당 도메인의 소유권을 검증받기 위해 우리의 도메인 주소를 넣는다.

명령어를 넣으면 인증서가 발급될 것이다.

여기서!! 저 디렉토리 안에 뭐가 생기는건 아니다!

명령어를 실행하면 certbot이 해당 디렉토리 안에 인증을 위한 파일을 넣고 Let'sEncrypt가 그 파일을 확인하기 위해 우리 서버에 접속 후 확인이 되면 인증서를 발급하면서 저 certbot-webroot 디렉토리 안에 파일을 삭제한다.

그래서 우리 눈에는 아무것도 안보임

4. crontab 으로 자동화

crontab을 통해 알아서 갱신되도록 하기 전에

sudo certbot renew --dry-run 을 통해 인증서가 갱신되는지 확인한다.

인증서가 갱신이 되는걸 확인했으면

sudo crontab -e 을 통해 스케쥴러 편집창을 열고

0 3 * * * certbot renew --quiet && docker exec muzipfront nginx -s reload 새벽 3시에 인증서를 갱신하고 muzipfront 컨테이너에서 nginx 설정을 다시 reload 하라는 명령을 넣어준다.

일단 이렇게 설정을 해뒀으니 되는지 안되는지는 3달 후에 알 수 있지 않을까? ㅋㅋ;;

현재 인증서는 갱신했기 때문에 끝!

종이를 여러 조각으로 잘라서 합을 구하는 문제

<풀이 방법>

1차 풀이 방법 - 시간 초과

dfs

각 칸에서 가로길이, 세로길이 가능한 만큼 확인하고 dfs로 다음 칸으로 넘어간다.

• 시간초과 이유 =>

n,m 이 4,4 일 때 한 칸에서 고려하는 경우의 수 = (가로 0,1,2,3) + (세로 0,1,2,3) = 8

탐색할수록 경우의 수는 줄어들긴 하지만 경우가 제곱으로 커짐

또한 계산하지 않아도 되는 경우까지 계산하게 됨.

-> 한 줄에 가로2칸 + 가로2칸 이면 따로 계산하는게 아니라 가로4칸으로 계산해서 하나로 이은 값이 더 크다.

2차 풀이 방법 - 정답

마찬가지로 dfs 이지만

각 칸을 가로칸으로 배치할 것인지 세로칸으로 배치할 것인지 정한다.

모든 칸을 전부 정했으면 붙어있는 칸이 같은칸이면 자릿수를 올려가며 더해주기.

<시간 초과>

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

public class Main {

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

    static int n, m, count, max = Integer.MIN_VALUE;
    static int[][] arr;
    static int[][] visited;

    // 오른쪽, 아래쪽만 고려
    static int[] dx = {1, 0};
    static int[] dy = {0, 1};

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

        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());

        arr = new int[n][m];
        visited = new int[n][m];

        for (int i = 0 ; i < n ; i ++) {
            String str = br.readLine();
            for (int j = 0 ; j < m ; j ++) {
                arr[i][j] = str.charAt(j) - '0';
                visited[i][j] = -1;
            }
        }

        dfs(0, 0, 0, 0);

        System.out.println(max);
    }

    static void dfs(int depth, int sum, int x, int y) {
        // 모든 칸을 전부 확인 했으면 합 계산
        if (depth == n * m) {
            if (sum > max) max = sum;
            return;
        }

        for (int i = x ; i < n ; i ++) {
            for (int j = (i == x ? y : 0) ; j < m ; j ++) {
                if (visited[i][j] == -1) {
                    // 세로로 얼마나 갈 지 정해서 가기
                    for (int h = 0 ; h < n - i ; h ++) {
                        // 이미 다른 종이 조각이 있으면 안됨.
                        if (avail(i, j, h, 0)) {
                            int val = chkLine(i, j, h, 0, count++);
                            dfs(depth + h + 1, sum + val, i, j);
                            chkLine(i, j, h, 0, -1);
                            count --;
                        }
                    }
                    // 가로로 얼마나 갈 지
                    for (int w = 0 ; w < m - j ; w ++) {
                        if (avail(i, j, w, 1)) {
                            int val = chkLine(i, j, w, 1, count++);
                            dfs(depth + w + 1, sum + val, i, j);
                            chkLine(i, j, w, 1, -1);
                            count --;
                        }
                    }
                }
            }
        }

    }

    // 갈 수 있는곳인지 검증하고 들어와야 함.
    // dir: 0 => 아래쪽, dir: 1 => 오른쪽
    static int chkLine(int x, int y, int len, int dir, int count) {
        int sum = 0;
        int temp = (int)Math.pow(10, len);

        for (int i = 0 ; i < len + 1 ; i ++) {
            int nx = x + dx[dir] * i;
            int ny = y + dy[dir] * i;
            visited[nx][ny] = count;

            sum += arr[nx][ny] * temp;
            temp /= 10;
        }

        return sum;
    }

    static boolean avail(int x, int y, int len, int dir) {
        for (int i = 0 ; i < len + 1 ; i ++) {
            int nx = x + dx[dir] * i;
            int ny = y + dy[dir] * i;

            if (visited[nx][ny] != -1) return false;
        }

        return true;
    }

}

<정답 코드>

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

public class Main {

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

    static int n, m, max = 0;
    static int[][] arr;
    static boolean[][] visited;

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

        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());

        arr = new int[n][m];
        visited = new boolean[n][m];

        for (int i = 0; i < n; i++) {
            String str = br.readLine();
            for (int j = 0; j < m; j++) {
                arr[i][j] = str.charAt(j) - '0';
            }
        }

        dfs(0, 0);

        System.out.println(max);
    }

    // 각 칸에 대해 가로/세로 선택
    static void dfs(int x, int y) {
        if (x == n) {
            calc();
            return;
        }

        int nextX = x;
        int nextY = y + 1;
        if (nextY == m) {
            nextX++;
            nextY = 0;
        }

        // 가로 조각으로 선택
        visited[x][y] = true;
        dfs(nextX, nextY);

        // 세로 조각으로 선택
        visited[x][y] = false;
        dfs(nextX, nextY);
    }

    // 종이 조각 합계 계산
    static void calc() {
        int sum = 0;

        // 가로 조각 계산
        for (int i = 0; i < n; i++) {
            int temp = 0;
            for (int j = 0; j < m; j++) {
                if (visited[i][j]) { // 가로 조각
                    temp = temp * 10 + arr[i][j];
                } else {
                    sum += temp;
                    temp = 0;
                }
            }
            sum += temp; // 줄 끝나면 더하기
        }

        // 세로 조각 계산
        for (int j = 0; j < m; j++) {
            int temp = 0;
            for (int i = 0; i < n; i++) {
                if (!visited[i][j]) { // 세로 조각
                    temp = temp * 10 + arr[i][j];
                } else {
                    sum += temp;
                    temp = 0;
                }
            }
            sum += temp; // 줄 끝나면 더하기
        }

        max = Math.max(max, sum);
    }
}

<풀이 방법>

1. 각 건물에서 건물 까지의 거리를 구해놓고

2. 어떤 건물에 치킨집을 차릴 지 조합을 구한다.

3. 건물에서 치킨집 사이의 거리를 구하는데 더 가까운 곳으로 계산한다.

각 건물 사이의 거리 구하기

여기서는 '플로이드-워셜' 을 사용하였다.

n 은 0 ~ 100인 만큼 100^3 해도 100만으로 제한시간 안에 계산이 가능하다.

'플로이드-워셜' 에서의 중요한 점은

3중 for문의 가장 바깥 for문이 '거쳐가는 노드' 인덱스여야 한다는 것.

그렇지 않으면 최신화된 정보를 통해 갱신하는것이 아니라 뒤죽박죽이 됨.

<정답 코드>

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

public class Main {

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

    static int n, m, min = Integer.MAX_VALUE, resultX, resultY;
    static int[] chicken;
    static int[][] arr;
    static boolean[] visited;

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

        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());

        arr = new int[n+1][n+1];
        visited = new boolean[n+1];
        chicken = new int[2];

        for (int i = 1 ; i <= n ; i ++) {
            for (int j = 1 ; j <= n ; j ++) {
                arr[i][j] = Integer.MAX_VALUE;
                if (i == j) arr[i][j] = 0;
            }
        }

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

            int from = Integer.parseInt(st.nextToken());
            int to = Integer.parseInt(st.nextToken());

            arr[from][to] = 1;
            arr[to][from] = 1;
        }

        floyd();

        dfs(0, 1);

        System.out.println(resultX + " " + resultY + " " + min * 2);

    }

    static void floyd() {
        for (int k = 1 ; k <= n ; k++) {
            for (int i = 1 ; i <= n ; i ++) {
                for (int j = 1 ; j <= n ; j ++) {
                    if (arr[i][k] == Integer.MAX_VALUE || arr[k][j] == Integer.MAX_VALUE) continue;
                    if (arr[i][j] > arr[i][k] + arr[j][k]) {
                        arr[i][j] = arr[i][k] + arr[j][k];
                    }
                }
            }
        }
    }

    static void dfs(int depth, int idx) {
        if (depth == 2) {
            int sum = 0;
            int x = -1;
            int y = -1;

            for (int i = 1 ; i <= n ; i ++) {
                // 치킨집 사이의 거리가 짧은것을 선택해서 합연산 하기
                sum += Math.min(arr[i][chicken[0]], arr[i][chicken[1]]);
            }

            if (min > sum) {
                resultX = chicken[0];
                resultY = chicken[1];
                min = sum;
            }

            return;
        }

        for (int i = idx ; i <= n ; i ++) {
            if (!visited[i]) {
                visited[i] = true;
                chicken[depth] = i;
                dfs(depth + 1, i);
                visited[i] = false;
            }
        }
    }
}

섹션 1 - API 개발 기본

1. 회원 등록 API

1. @Valid 어노테이션을 붙여서 파라미터 유효성을 검증하자

엔티티 내 @NotEmpty 같이 유효성을 검증해야 하는 컬럼들이 있고 API 요청이 들어오면 들어온 파라미터 값을 검증해주는 역할을 한다.

@NotEmpty가 없으면 해당 필드 값이 null 이더라도 넘어가진다.

2. @RequestBody로 들어오는 파라미터에는 엔티티 그대로 받지 않는다.

API 요청 시 Entity의 필드변수 명 그대로 요청 보내야 하는데 나중에 변경이 된다면 Bad Request 발생

전용 DTO를 만들어서 받아주도록 하자

전용 DTO로 만들어 주는 방법

위와 같이 만들었을 때 Entity 내 name이라는 컬럼이 바뀌었을 때 -> 당연히 setName 에서 컴파일 에러가 떠서 에러를 잡을 수 있고 -> CreateMemberRequest 라는 DTO에 컬럼 속성을 지정해서 DTO만 보고 확인할 수 있다.

실무에서는 절대 엔티티를 외부에 노출시키거나 그대로 받으면 안된다.

2. 회원 수정 API

1. DTO를 받아서 쓰면 DTO에는 @Data 어노테이션 꼽아서 사용해도 무방

2. 수정할 때는 변경감지(더티체킹)를 사용하도록 하자

수정하기 위한 객체를 가져와서 가져와서 수정해주기

3. 회원 조회 API

1. findMembers 할 때 Java8의 stream을 사용하는데 findAll 과의 차이점은 뭐지?

: 인터넷에서 사용하는 텍스트 기반의 데이터 전송 프로토콜

구글에서는 인터넷을 켰을 때 HTTP 프로토콜을 사용하면 '안전하지 않은 사이트' 라고 나옴 -> 서버에서 클라이언트로 전송되는 데이터는 암호화 되지 않은채로 보내진다.

• 구글에서 권장하는 프로토콜은 HTTPS 이다.

HTTPS (HTTP + Secure)

: HTTP에 보안(SSL: Secure Sockets Layer)을 더한 프로토콜

SSL을 더함으로써 전송되는 데이터가 암호화 되어 정보를 도난당하지 않게 된다.

letsencrypt 를 통해 https 인증서를 받는다.

sudo apt-get install letsencrypt
sudo letsencrypt certonly --standalone -d <도메인>

이 인증서는 90일 유효하므로 기한이 끝나기 전 갱신을 해주거나 certbot을 통해 자동으로 갱신되게 하는 시스템이 있어서 그걸 사용해야 한다고 함 (여기서는 일단 90일 인증서로 진행)

2. Jenkins 내 Docker 설치

jenkins 컨테이터 접속 후 설치해준다.

docker exec -it jenkins bash

            apt-get update && \
            apt-get -y install apt-transport-https \
                ca-certificates \
                curl \
                gnupg2 \
                software-properties-common && \
            curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add - && \
            add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable" && \
            apt-get update && \
            apt-get -y install docker-ce-cli

set hlsearch
set nu
set autoindent
set ts=4
set sts=4
set cindent
set laststatus=2
set shiftwidth=4
set showmatch
set smartcase
set smarttab
set smartindent
set ruler
set fileencodings=utf8,euc-kr

2. 서버 시간 설정하기

sudo timedatectl set-timezone Asia/Seoul

3. ufw 포트 열기

sudo ufw allow 80
sudo ufw allow 3209   // DB 포트 (3306 대신)
sudo ufw allow 8545   // ganache-cli 포트

sudo ufw enable

4. 카카오 미러서버 설정하기

sudo vim /etc/apt/sources.list

여기서 서버 주소를 mirror.kakao.com 으로 바꿔준다.

아래쪽에 security.ubuntu.com 도 바꿔 줘야하는듯.

*vim 치환 명령어 :%s/hello/world -> hello 라는 문자열을 world 라는 문자열로 치환한다.

ex) :%s/security.ubuntu/mirror.kakao

5. apt update

sudo apt-add-repository -r ppa:certbot/certbot

sudo apt update
sudo apt-get update
sudo apt-get upgrade

순서 대로 작성은 할 것인데 생각의 흐름 대로 적어 글에 두서가 없을 수 있습니다.

Docker 설치

sudo apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-common

• apt-transport-https : 패키지 관리자가 https를 통해 데이터 및 패키지에 접근할 수 있도록 한다.
• ca-certificates : ca-certificate는 certificate authority에서 발행되는 디지털 서명. SSL 인증서의 PEM 파일이 포함되어 있어 SSL 기반 앱이 SSL 연결이 되어있는지 확인할 수 있다.
• curl : 특정 웹사이트에서 데이터를 다운로드 받을 때 사용
• software-properties-common : *PPA를 추가하거나 제거할 때 사용한다.

Docker의 공식 GPG키를 추가

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Docker의 공식 apt 저장소를 추가

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

시스템 패키지 업데이트

sudo apt-get update

Docker 설치

sudo apt-get install docker-ce docker-ce-cli containerd.io

Docker 설치 시 Permission denied

sudo usermod -aG docker [계정명을 기입하시오]
cat /etc/group | grep docker

or

sudo groupadd docker
sudo usermod -aG docker $USER
sudo newgrp docker

CI

jenkins 설치

CI/CD : Continuous Integration/Continuous Delivery

spring boot 3.2.x 버전의 서버를 돌리므로 jdk17 버전의 jenkins를 사용한다.

추후에 DooD 를 사용하기 위해 jenkins의 볼륨을 마운트 해줘야 하는데 jenkins를 껐다켤때마다 다시 옵션을 설정해줘야 하는 번거로움이 있다. 이를 모두 기억하기 힘드니까 도커 컴포즈 파일로 만들어서 빌드한다.

그리고 여러개의 도커 컴포즈 파일을 만들 수 있으므로 composeFiles라는 디렉토리를 만들어서 관리하도록 하고

그 안에 docker-compose.jenkins.yml 을 만들어 준다.

• docker-compose.jenkins.yml

  version: "3.8"
  

services: jenkins: container_name: jenkins image: jenkins/jenkins:jdk17 restart: unless-stopped user: root ports: - 9090:8080 volumes: - /home/ubuntu/jenkins:/var/jenkins_home - /home/ubuntu/.ssh:/root/.ssh - /var/run/docker.sock:/var/run/docker.sock

+04.24 추가) 계속 젠킨스 컨테이너 내 도커를 설치했을 때 다음부터 접속이 안되는 문제가 있어서 서버를 몇 번 초기화했다. /home/ubuntu/.ssh:/root/.ssh를 마운트 하면서 진행하는데 이 부분에서 문제가 발생하는 것이 아닌지 의심중 ->

* volumes 설명
1. /home/ubuntu/jenkins
: jenkins에서 코드를 클론하면 /home/ubuntu/jenkins 안에
workspace 라는 곳 안에 들어가게 됨.
2. /home/ubuntu/.ssh
: ubuntu를 외부에서 접속했을 때 root 로 접속이 가능하게 하기 위함
( 이게 필수인지는 잘 모르겠음, 권한 문제 때문에 필요한 것 같음 )
3. /var/run/docker.sock
: jenkins 컨테이너가 docker.sock을 통해 docker host에게 명령을 전달하기 위해 마운트 해주고 사용한다.

추가) - docker.sock
![](https://velog.velcdn.com/images/sh_38/post/99bb2c26-a1ae-4edc-821e-c563d7507cc6/image.png)

docker.sock 은 항상 명령을 받을 준비를 한다. 얘를 컨테이너가 사용하기 위해 볼륨으로 마운트 해주는 것

- jenkins 컨테이너 생성

$ docker compose -f dockerFiles/docker-compose.jenkins.yml up -d --build

* 옵션 설명
1. -f : 파일 직접 지정 (설정 안해주면 현재 디렉토리에서 docker-compose.yml 을 빌드함)
2. -d : detached 옵션으로 실행 (백그라운드 에서 실행)
3. -- build : 컨테이너 생성시 이미지를 다시 생성하는 옵션

실행했으면 브라우저에서 접속해보기
-> ```$ docker ps -a``` 로 로그 확인해보고 켜졌는지 확인
-> 안되면 ec2 인스턴스 보안그룹에서 포트 설정 확인하기
-> 안되면 ec2 방화벽 설정 해주기 ```$ sudo ufw status``` 확인해보기

접속했다면
```$ docker logs jenkins``` 를 입력해서
설치를 위한 비밀번호 복사한 후 사이트에 붙여넣고 기본(권장) 설치로 설치하기

- 비밀번호
![](https://velog.velcdn.com/images/sh_38/post/34dcf1d8-ba00-432f-aa2b-952bddb799a7/image.png)


- 설치화면
![](https://velog.velcdn.com/images/sh_38/post/16215701-1404-41d7-9e33-87c153b26f70/image.png)


우리는 CI/CD를 구축하는데
Pipeline으로 구축하겠다
->
1. 빌드하는데 각 단계별로 모니터링 가능하면서
2. 에러가 어디서 발생했는지 쉽게 볼 수 있고
3. 스크립트를 짜서 관리가 쉽다.

단점 : 스크립트를 짤 줄 알아야 한다.

## jenkins 시작

item을 생성할 때 pipeline으로 생성해준다.

![](https://velog.velcdn.com/images/sh_38/post/6a4bbdb8-b670-4700-9312-6aa49e6c95df/image.png)

Pipeline script 는 웹 페이지 상에서 스크립트를 작성해서 적용시키는 방식이고
밑에 SCM 은 jenkinsfile로 스크립트 명령어를 관리하는 방식을 채택한다는 뜻.

우리는 웹에다 바로 적자

``` node
pipeline {
    agent any

    stages {
        stage('Clone') {
            steps{
                git branch: '{변경 감지 할 브랜치}', credentialsId: '{credential 아이디}', url: '{web-hook 보내는 git 리포지토리 주소 ex) ~~.git}'           
                sh "sed -i 's/{docker-compose.yml에서 암호화된 JASYPT_KEY}/{암호화 전 키}/g' docker-compose.yml"
                sh "cat docker-compose.yml"
            }

        }
        stage('Build'){
            steps{
                dir('backend/farmyo') {
                    sh "chmod +x gradlew"
                    sh "./gradlew clean build"
                }
            }

        }
        stage('Deploy') {
            steps{
                // 이전에 실행된 컨테이너를 중지하고 삭제합니다.
                sh "docker stop farmyo-backend || true"
                sh "docker rm farmyo-backend || true"

                sh "docker stop farmyo-frontend || true"
                sh "docker rm farmyo-frontend || true"

                // 이전에 빌드된 이미지를 삭제합니다.
                sh "docker rmi farmyo_pipeline-farmyo-frontend || true"
                sh "docker rmi farmyo_pipeline-farmyo-backend || true"

                sh "docker ps -a || true"
                sh "docker images || true"

                sh "docker compose build --no-cache"
                sh "docker compose up -d"
            }
        }
    }
    post {
        success {
            script {
                def Author_ID = sh(script: "git show -s --pretty=%an", returnStdout: true).trim()
                def Author_Name = sh(script: "git show -s --pretty=%ae", returnStdout: true).trim()
                mattermostSend (color: 'good', 
                message: "빌드 성공 ^_^ v : ${env.JOB_NAME} #${env.BUILD_NUMBER} by ${Author_ID}(${Author_Name})\n(<${env.BUILD_URL}|Details>)", 
                endpoint: '{deploy 알림을 받을 Mattermost 채널 주소}', 
                channel: '{알림 받을 채널 명}'
                )
            }
        }
        failure {
            script {
                def Author_ID = sh(script: "git show -s --pretty=%an", returnStdout: true).trim()
                def Author_Name = sh(script: "git show -s --pretty=%ae", returnStdout: true).trim()
                mattermostSend (color: 'danger', 
                message: "빌드 실패 ㅜ_ㅜ : ${env.JOB_NAME} #${env.BUILD_NUMBER} by ${Author_ID}(${Author_Name})\n(<${env.BUILD_URL}|Details>)", 
                endpoint: '{deploy 알림을 받을 Mattermost 채널 주소}', 
                channel: '{알림 받을 채널 명}'
                )
            }
        }
    }
}

Credentials

jenkins 에서는 git에 수정사항을 Webhook을 통해서 감지하게 되는데 여기서 해당 repository 의 코드를 받아와야 한다.

그러기 위해서는 git 접근 권한을 줘야 한다. -> repository가 public 이면 굳이 권한까지 필요는 없다고 함

그래도 일단 적용 해보자 ( private로 할 수 있으니까 )

GitHub 에서

1. git 에서 프로필 누르면 나오는 settings -> Developer settings
2. generate new token

3. read only로 토큰 생성 ( 날짜는 알아서 )

해당 토큰 값을 복사해둔다. 중요!!

jenkins 에서

1. jenkins 관리 -> Credentials -> system
2. global Credentials -> add Credentials
3. 값 넣고 생성하기 kind는 'Secret Text' Secret 은 아까 깃에서 복사해둔 토큰값 ID는 변수명 알아서 후 생성

++ 추가 나는 이 플러그인이 안깔려 있어서 파이프 라인이 GUI 로 안보였음 jenkins에서 설치 안되어있으면 설치하시길

webhook 설정

webhook 용 토큰을 repo, repo_hook 옵션을 체크 해주면서 하나 만들어 주자

그리고 jenkins에 credentials로 등록해준다.

• webhook token 등록 여기서 password 는 webhook 토큰 생성시 나오는 값 복붙하기.

• jenkins 환경설정에서 github server 등록해주기

• 프로젝트에서 webhook 을 받도록 설정

webhook을 보낼 repository에 들어가서

이렇게 설정 해주면

초록색 체크 표시가 뜬다. 그러면 CI 구축 완료

+) 추가

GitLab 에서

Personal Access Token 생성은 여기서 해준다.

Project Access Token은 이렇게 생성한다.

기한은 2달정도로 잡고 권한은 일단 필요해 보이는거 선택했다.

webhook 설정

jenkins 에서 gitlab 플러그인을 설치한다.

"Solidity에 대한 개념을 제가 이해한 방식으로 풀어 쓴 글입니다."

스마트 컨트랙트

백엔드 개발을 해보고 나서 바로 블록체인 공부를 하게 되었습니다. 이 블록체인의 스마트 컨트랙트를 보고 느낀점

1. 백엔드 서버를 블록체인 블록으로 관리한다.
2. 서버를 최대한 효율적으로 짜야 한다.

API를 호출하고 데이터를 받으려면 서버는 항상 켜져있어야 함 반면 블록체인은 컨트랙트를 블록체인에 등록함으로써 블록체인 서버는 항상 켜져있고 거기에 내 API를 추가하는 느낌

그래서 켜져있는 서버에 API를 등록하고 사용하려면 AWS를 빌려서 서버비를 내는것처럼 서버 사용료를 내야겠죠?

그 사용료를 gas라고 하자

1 eth(이더리움) = 10^9 Gwei (가스웨이) = 10^18 wei(웨이)

1 gas = 1 Gwei

• 그럼 이 gas는 어떻게 책정되는가?

AWS ec2 서버도 한정적인 리소스가 있고 그 리소스를 사용하는데 공평하게 사용하기 위해 프로세스들이 나눠서 돌아가며 사용하는데

모든 사람들이 이 블록체인 서버를 공평하게 사용하기 위해서는 리소스를 사용하는 양에 맞추어 gas를 매겨야 합니다.

Ethereum Yellow Paper

그 기준은 위 논문 27페이지 쯤에 나와있습니다.

컨트랙트에서 어떤 행동을 하느냐에 따라 얼마의 gas가 부과되고

해당 함수가 자원을 얼마나 사용하나에 따라 gas가 부과 되는 구조입니다.

즉

우리는 컨트랙트의 함수를 실행하는데 드는 비용 (gas)를 최소한으로 하기 위해

함수를 만들때 부터 딱 필요한 범위 내에서, 딱 필요한 기능만 동작하게 만들어야 합니다.

솔리디티는 function에서 사용되는 키워드 하나하나 마다 책정되는 gas가 다름

• 접근제어자

• view, pure, payable

• 사용되는 파라미터 변수의 존재 범위

gas를 사용하는 범위를 세세하게 나눠 두었기 때문에 변수에 접근제어자 선택 안해주고 그냥 아무렇게나 변수 사용하면 난방비 엄청 나올 준비 하셔야 합니다.

• 내가 볼려고 정리한 것들

external vs public external 키워드의 경우, 컨트랙트의 외부에서만 함수의 호출이 가능하게 합니다. 반면 public 키워드의 경우 컨트랙트의 내부와 외부 모두에서 함수의 호출이 가능하게 합니다.

internal vs private internal 키워드의 경우, 컨트랙트 내부 또는 해당 컨트랙트를 상속하는 컨트랙트에서 호출이 가능합니다. 다른 언어의 protected 키워드와 유사하다고 생각하시면 됩니다. 반면 private 키워드의 경우, 컨트랙트 내부에서만 호출이 가능합니다.

view : function 밖의 변수들을 읽을수 있으나 변경 불가능 pure : function 밖의 변수들을 읽지 못하고, 변경도 불가능 viwe 와 pure 둘다 명시 안할때: function 밖의 변수들을 읽어서, 변경을 해야함.

캐시 메모리

프로세스가 동작할 때는 하드디스크에서 데이터를 가져와서 메인 메모리(RAM) 에 올려놓고 사용합니다.

메인 메모리가 하드디스크 보다 빠르기 때문에 올려두고 빠르게 접근하기 위함입니다.

그런데 여기서 CPU를 더 효율적으로 사용하기 위해 CPU가 접근하기 쉬운 공간을 하나 마련해둡니다.

그것을 캐시 메모리 라고 합니다.

자주 사용하는 데이터를 쌓아두고 있다가 필요하면 바로바로 꺼내주는 역할을 합니다.

캐시 메모리는 속도가 빠른만큼 가격이 비쌈 => 적은 용량을 효율적으로 사용해야 함

Redis (Remote Dictionary Server)

서버에서 1만명이 DB의 '싸피' 라는 데이터가 필요하다고 할 때

서버에서는 이 데이터를 꺼내 보여주기 위해 1만번의 조회가 발생합니다.

하지만 '싸피' 라는 데이터를 캐시 메모리에 올려놓는다면 한번의 DB 연결로 캐시 메모리에 '싸피'를 올려두고 빠르게 데이터를 제공할 수 있겠죠

이 역할을 하는것이 Redis 입니다.

Redis는

1. In Memory 에 데이터를 저장하여
2. 자주 사용하지만 변경되지 않는 데이터에게
3. 빠르게 접근하기 위한 서버의 캐시메모리 입니다.

Redis의 장단점

장점

1. DB 접근을 줄여줄 수 있다.

2. No-Sql로 Key: value 쌍으로 접근할 수 있다. (RDBMS 보다 빠르다고 함)

3. 문법적으로 사용하기 쉽다.

단점

1. DB에서 데이터를 직접 가져오는것이 아니기 때문에 DB와 다를 수 있다. 즉 자주 변경되는 데이터를 사용하면 데이터가 불일치 되는 경우가 발생할 수 있음

2. 휘발성 메모리에 저장하기 때문에 서버를 끄면 데이터가 사라짐

사용처

1. 일반적으로 사용자의 세션 관리

   • 사용자의 세션을 유지하고, 관리하고, 여러 활동들을 편리하게 추적할 수 있다고 합니다. Refresh 토큰을 발급한걸 가져오면 좋을 듯 합니다. 토큰 관리 관련 블로그

2. 메세지 큐잉

   • 속도가 매우 빨라서 실시간 채팅에 사용이 가능하다고 합니다. 대화 내용을 저장하지 않는 경우에 사용하기에 좋아보입니다. 채팅 관련 블로그

no supported authentication methods available (server sent publickey gssapi-keyex gssapi-with-mic)

다른 블로그에서 시킨 대로 PuTTY로 SSH 접속을 시도했는데 계속 위 에러가 발생했다.

해결 방법

계속 안되다가 이 두가지 방법을 하고 나서 접속이 가능했음.

1. AWS 에서 인스턴스를 다른 인스턴스로 생성하기. (이전에는 Amazon Linux 2023 AMI (처음에 선택 되어있음) 을 사용 함.)

-> Amazon Linux 2 AMI 저걸로 인스턴스 생성 했음.

![](https://velog.velcdn.com/images/sh_38/post/21a9de61-b850-4509-bb68-40d07d73faec/image.png)

2. PuTTY 를 최신 버전으로 다시 설치함

-> 혹시나 싶어 업데이트를 했는데 PuTTY 설정 화면이 조금 다름. 업데이트는 해주는게 좋을 듯.

1. 구글 찾아보면 무슨 .ssh 파일 접근 권한을 설정해줘야 한다고 해서 설정 해줬는데, 안되고
2. 서버안에 authentication파일 안에 퍼블릭 키를 넣어줘야 한다고 해서 넣어주고 해도 안되고
3. /etc/bin/ssh? 무슨 로컬 파일 경로에 passAuthentication 머시기? 주석 풀고 해보라길래 해봐도 안되고 아무리 해봤는데도 안됐음...

추가

01.15 -> PuTTY 가 문제였는것으로 보임

'Amazon 2023 AMI' 을 사용해도 문제가 없음

만약 위 에러가 계속 발생한다면 아래의 해결 방식을 따라보는 것을 추천함.

1. ec2를 새로 생성한다.

새로 생성하면서 key를 .pem 으로 새로 생성하고 파일을 저장한다. 만약 현재 서버에 뭐가 많아서 서버를 지우기 좀 그렇다면 --> 키를 생성해서 해당 인스턴스에 다시 등록해줘야 한다. 인스턴스를 생성할 때 마다 key가 등록이 되는데 이 키는 생성할 때 받아두는 방법 밖에 없어서 그 key 파일을 잃어버렸다면 새로운 키를 발급 받아 직접 인스턴스에 등록해야 한다.

key를 재발급해서 등록하는것은 찾아보길 바람.

2. .pem 키를 .ppk 키로 바꿔준다.

ec2 생성시 받는 key 페어는 .pem으로 받아서 .ppk로 바꿔줘야 한다. 물론 생성할 때 .ppk로 (for PuTTY) 인가 이렇게 옵션이 있을텐데 이걸 사용하니까 안 됨.

PuTTY에서는 이 키가 옛날 형식의 키라고 뜨면서 거부함.

그래서 PuTTYgen 을 통해서 .ppk 키를 만들고 사용해줍시다.

ec2 인스턴스 생성은 구글에 쳐보면 생성하는 방법이 다 나와있습니다. 잘 따라 해보시면 됩니다.

생성 도중에 놓칠 수 있는 부분에 대해서 설명하자면

1. aws ec2를 생성할 때 생성하는 .pem 형식의 key를 꼭 받아두세요..!

인스턴스 생성 시 '키 페어' 를 생성하고 등록하는 과정이 있는데 '새 키 페어 생성' 하시고 생성된 키 페어를 꼭 저장하신 후 생성하세요

이 .pem 키를 받아서 PuTTYgen 이라는 .ppk 생성 프로그램으로 PuTTY 전용 key를 생성해서 사용하게 됩니다. (ec2 생성할 때 바로 .ppk 키를 받아서 사용하면 인증 방식이 구버전이라고 사용이 불가능한 이슈가 있었습니다.)

2. 볼륨 크기는 30GB 까지 무료입니다.

프리티어를 사용하신다면 볼륨 크기가 30GB까지 무료이기 때문에 이를 적극 사용하시기 바랍니다.

1 x 30GiB로 설정하면 됨.

RDS 서버 생성

RDS 또한 생성하는 것은 구글에서 검색하면 다 나오기 떄문에

여기서는 RDS 생성시 설정한 내용들과 몇가지 주의사항을 짚고 넘어가겠습니다.

RDS는 나도 모르게 과금 될 수 있는 설정이 몇가지 있습니다.

* 다중 AZ 설명 (요약 설명하자면 DB 서버에 에러가 발생했을 시, 이를 대처하기 위한 또 다른 서버를 한대 더 가동하고 있는 것) -> 프리티어에서는 안된다고 했는데 체크해버리면 과금될 위험이 있을지도...?

스토리지 자동 조정이 할당된 용량을 벗어나면 알아서 늘려버리는 옵션입니다. 나도 모르게 돈이 나가는 불상사를 막기 위해 체크를 풀어줍니다.

퍼블릭 액세스는 풀어서 workbench 에서도 연결이 가능하게 해줍니다. '아니요' 를 체크하면 VPC 내에서만 사용이 가능하게 되는데 VPC란 amazon Virtual Private Cloud의 약자로 아마존 인스턴스들 관계에서만 사용이 가능합니다. 즉 ec2로만 접근하게 된다는 말.

위 옵션은 필요한 사람들은 사용하면 됩니다.

마이너 버전 자동 업그레이드 --> 몇달에 한번씩 취약점 보완을 위한 마이너 버전에 대한 업데이트가 발생함. --> 몇분 길면 한시간 동안 db 사용이 불가능해진다는 점이 있음.

각 인스턴스 생성 후 ec2와 RDS 연결은 같은 VPC/보안 그룹 환경에 ec2와 RDS를 넣어주면 됩니다.

ec2와 RDS 생성 시 놓칠 수 있는 부분에 대해서 다루어 보았습니다.

ec2 인스턴스를 생성하기에 앞서...

우리는 free tier를 사용하기 때문에 t2.micro 컴퓨터를 사용하는데 얘는 기본적으로 Linux 운영체제가 탑재되어 나옵니다. (Linux 는 오픈소스라 무료임)

그렇기에 우리는 Linux를 사용할 줄 알아야 하겠죠. 맞죠?

Linux는 Shell Script로 사용을 할 수 있습니다.

Windows 에서는

마우스를 움직여서 메모장을 켜고, 내용을 입력을 하고, 마우스로 저장 버튼을 누르거나 Ctrl+S를 해서 저장하고, 저장된 .txt 파일을 더블클릭으로 켜는 과정들을 Linux에서는 Shell 환경에서 명령어를 입력해서 수행해야합니다.
ex)

• pwd : 사용자가 현재 들어가있는 폴더(디렉토리)의 위치를 보여줌 - present working directory 의 약자
• ls : 현재 폴더(디렉토리) 안에 어떤 파일들이 있는지 보여줌 - list의 약자

SSH

Secure SHell 의 약자 22번 포트를 사용합니다.

다른 컴퓨터의 쉘을 사용하게 해 주는 프로그램 혹은 프로토콜을 말합니다.

Shell에 접근하는데 들어갈 수 있는 사람들을 제한하기 위해 Shell에 들어가려면 Key 가 필요한 시스템임

Key는 파일 형태로 넣어줍니다.

PuTTY

PuTTY는 이런식으로 생겼고 위의 HostName 에는 접속하고자 하는 컴퓨터의 IP주소를 넣어줍니다.

그리고 Auth 탭에 가면 접속에 필요한 Key 파일을 넣어주고 Open 하면 접속이 가능합니다.

여기까지는 SSH와 PuTTY에 관한 설명이고

다음에는 ec2 인스턴스를 생성해보겠습니다.

클라우드 서비스 플랫폼이다.

서버를 구축하는데 필요한 여러 장치들을 클라우드 환경에서 제공해주는 서비스

서버를 구동하기 위해서는

• 본인의 컴퓨터를 서버로 사용하기
• 가상의 컴퓨터를 서버로 사용하기

두 가지의 방법이 존재하는데

전자를 온 프레미스(on-premise), 후자를 클라우드 방식이라고 한다.

우리가 클라우드 서비스를 사용하는 이유?

1. 서버는 비싸다
   • 직접 돈주고 환경을 맞추려면 비쌈
2. 보안을 대신 책임져준다
   • 아마존은 대기업인 만큼 보안을 철저히 관리한다
3. 필요한 리소스를 유동적으로 사용할 수 있다
   • 많은 용량이 필요한게 아니라면 용량을 줄일 수 있고 갑자기 많이 필요해지면 더 사용할 수 있다

이러한 장점들이 있으므로 기업에서도 많이 사용한다.

aws 에서 제공하는 서비스

<출처> - AWS 의 기본 서비스 S3, EC2, RDS에 대하여

1. S3 (Simple Storage Service)

데이터를 저장하거나 꺼내오는 서버임

S3 는 버킷이라는게 있다. 버킷에는 key와 value의 형태로 데이터가 저장되는데 하나의 value(object)는 하나의 key를 갖는다. 이 value는 실제 데이터가 저장되는 파일 부분과 객체의 메타데이터(생성일, 크기, 유형)로 구성된다.

key - obj{ file + metaData }

버킷

• 버킷은 S3에서 생성할 수 있는 최상위 디렉토리로 Region 별로 생성이 가능하며
• 버킷의 이름은 모든 Region에서 유일 해야 한다.
• 버킷은 계정 별 100개까지 생성이 가능하다.

데이터에 대한 접근은 http://{버킷명}.S3.amazonaws.com/{객체키}

ex) photo 라는 버킷이 있고 그 안에 animal/dog.jpg 라는 key를 가진 사진 파일이 있을 수 있다. -> http://photo.S3.amazonaws.com/animal/dog.jpg 로 데이터에 대한 접근이 가능하다.

사진, 동영상

특징

1. S3에는 저장할 수 있는 파일 수 및 용량의 제한이 없다 (물론 쓴 만큼 비용을 냄) 다만 각 객체의 크기는 최소 0Byte에서 5TB까지 이다. 하나의 PUT 요청으로 업로드 가능한 객체의 크기는 5GB 이다.

2. 모든 PUT, DELETE (삽입, 삭제) 요청에 대해 read-after-write(쓰기 후 읽기) 정책을 기본으로 한다. 그래서 GET, LIST (읽기) 요청은 모든 데이터가 수정이 완료 된 후 이루어 지게 되므로 일관성이 보장된다.

3. Lock 기능을 제공하지 않아 여러 쓰레드에서 동시에 같은 객체에 접근할 경우 문제가 생길 수 있다. ( + 객체에 대해 Transaction 처리를 지원하지 않는다. -> 개별 객체에 대한 원자성만 보장한다. )

2. EC2 (Elastic Computed Cloud)

인터넷 환경에서 저 멀리있는 컴퓨터를 빌려서 원격으로 서버를 운용 해주는 서비스임.

가상의 컴퓨터에 운영체제를 설치하고, 프로그램을 설치해서 서버를 구축할 수 있다. 여기서는 하나의 컴퓨터를 인스턴스 라고 표기한다.

ec2를 사용하는 이유?

1. 저렴하다.

2. 사용자가 인스턴스를 완전히 제어할 수 있다.

3. 보안을 aws 에서 관리해준다.

4. 내가 사용하고자 하는 서버의 용량을 탄력적으로 늘리거나 줄일 수 있다.

3. RDS (Relational Database Service)

RDB (Relational Database) 를 간편하게 운영, 설정, 확장할 수 있게 해주는 서비스이다.

EC2 내부에 MySQL을 설치해서 EC2 내부에서 사용할 수도 있지만, 보통 DB를 위한 별도 RDS를 만들어서 작업한다고 한다. DB 서버를 따로 분리하는 개념.

RDS는 여러가지 RDBMS를 지원하기 때문에 주로 사용하는 DBMS를 사용하면 된다. (ex : MySQL, oracle, MariaDB, Postgre)

비용이 발생하는 서비스인 만큼 굳이 사용을 안해도 상관은 없으나 사용을 하면 DB서버를 따로 분리하여 데이터 손실이나, 유지에 대한 부담을 덜 수 있다.

결국 서비스의 유지보수 및 속도 측면에서 어떤것이 좋을지 생각해 볼 수 있다.