
![2024-08-19-MasteringLogStatementsinJavaSpringBootBestPracticesExamplesandLogLevelConfiguration_0.png]

안녕하세요, 개발자 여러분!

자바 Spring Boot에서 로깅은 애플리케이션의 흐름을 추적하고 문제를 진단하며 상태를 이해하는 데 중요합니다. 새로 오신 분이든 경험이 많은 분이든 효과적인 로깅을 습득하면 디버깅 및 모니터링 역량이 향상됩니다. 이 간단한 가이드에서는 다음 사항을 다룰 것입니다:

- Best Practices: 중요한 로그 문장 작성 방법을 배워보세요.
- Examples: 명확하고 실용적인 예제를 통해 어떻게 하는지 확인해 보세요.
- Do’s and Don’ts: 무엇을 로그로 남길지, 건너뛸지 알아봅니다.
- Log Levels: 각 로그 레벨의 차이와 어떤 경우에 사용해야 하는지 이해합니다.
- Configuration: 다양한 로그 레벨을 활성화하거나 비활성화하는 방법을 알아봅니다.

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

자, 함께 들어가서 로깅을 활용해보는 건 어때요?

자바 스프링 부트에서 로깅이 중요한 이유

로깅은 소프트웨어 개발 세계에서 생명선과 같아요. 다음과 같은 이점을 제공해줍니다:

- 실행 흐름 추적: 코드가 실행되는 경로를 이해합니다.
- 문제 진단: 잘못된 부분을 식별합니다.
- 애플리케이션 상태 모니터링: 성능과 잠재적 병목 현상을 주시합니다.
- 사용자 활동 감사: 보안 및 규정 준수를 위해 중요한 사용자 활동을 추적합니다.

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

1. Java Spring Boot에서 로그인하는 위치

전략적 배치: 로그 문을 배치하는 위치를 알아내는 것은 유용한 로그를 만드는 데 중요합니다.

- 애플리케이션 시작 및 종료: 애플리케이션이 시작되고 종료될 때 로그를 남깁니다.

```js
logger.info("애플리케이션이 성공적으로 시작되었습니다.");
logger.info("애플리케이션이 종료 중입니다.");
```

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

- 오류 처리: 항상 예외와 오류를 기록하여 실패 지점을 정확히 파악하세요.

```javascript
try {
    // 일부 코드
} catch (Exception e) {
    logger.error("오류가 발생했습니다: ", e);
}
```

- 중요한 비즈니스 로직: 비즈니스 로직에서 중요한 이벤트를 기록하여 애플리케이션의 동작을 추적하세요.

```javascript
logger.info("사용자 {}가 로그인했습니다.", userId);
```

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

- 외부 시스템 상호작용: 투명성을 위해 외부 시스템과의 상호작용을 로그로 기록합니다 (예: API, 데이터베이스).

```js
logger.debug("외부 API에 요청 보내는 중: {}", requestPayload);
logger.debug("외부 API로부터 응답 수신: {}", responsePayload);
```

2. 자바 스프링 부트에서 로깅해야 하는 내용 및 로깅해서는 안 되는 내용

로그하는 항목:

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

- 에러 및 예외: 항상 스택 트레이스와 함께 이러한 것들을 로그에 남기세요.

```js
logger.error("요청 처리 중 예외가 발생했습니다: ", exception);
```

- 중요한 상태 변화: 애플리케이션에서 중요한 상태 변경 사항을 캡처하세요.

```js
logger.info("주문 상태가 {}에서 {}(으)로 변경되었습니다", oldStatus, newStatus);
```

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

- 성능 지표: 성능이 중요한 섹션에 걸린 시간을 추적합니다.

```js
long startTime = System.currentTimeMillis();
// 코드 실행
long endTime = System.currentTimeMillis();
logger.info("methodX 메서드의 실행 시간: {} ms", (endTime - startTime));
```

- 사용자 작업: 감사 목적으로 중요한 사용자 작업을 로깅합니다.

```js
logger.info("사용자 {}가 {} 작업을 수행했습니다", userId, action);
```

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

로그하지 말아야 할 내용:

- 민감한 정보: 패스워드, 신용카드 번호 또는 개인 정보와 같은 민감한 데이터는 로깅하지 말아야 합니다.

```js
// 좋지 않은 예시
logger.info("사용자 비밀번호: {}", password);
```

- 과도한 세부 정보: 로그를 메우는 과도한 세부 정보를 로깅하지 마세요. 필요한 경우가 아니라면 모든 변수와 모든 메소드 호출을 로깅하지 마세요.

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

3. 자바 스프링 부트에서 로그 레벨 이해하기

로그 레벨은 메시지의 심각성 또는 중요성을 정의합니다. 가장 심각한 것부터 가장 중요하지 않은 것까지 로그 레벨은 다음과 같습니다:

- ERROR: 즉각적인 주의가 필요한 심각한 문제를 나타냅니다. 어플리케이션이 계속 실행되는 것을 방해할 수 있는 중요한 문제를 기록합니다.

```js
logger.error("트랜잭션 처리 실패 {}", transactionId, exception);
```

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

- WARN: 잠재적으로 해로운 상황을 나타냅니다. 심각하지는 않지만 살펴봐야 할 문제에 대한 경고를 기록합니다.

```js
logger.warn("Memory usage is high: {}%", memoryUsage);
```

- INFO: 대략적인 수준에서 응용 프로그램의 진행 상황을 강조하는 정보 메시지를 제공합니다.

```js
logger.info("Service started on port {}", port);
```

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

- DEBUG: 애플리케이션을 디버깅하는 데 가장 유용한 세밀한 정보 이벤트를 제공합니다.

```js
logger.debug("userId에 대한 사용자 세부 정보 가져 오기: {}", userId);
```

- TRACE: DEBUG보다 더 세밀한 매우 상세한 로깅 정보를 제공합니다.

```js
logger.trace("파라미터로 methodX 시작: {}", params);
```

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

4. 스프링 부트에서 로그 레벨 구성하기

애플리케이션.properties 또는 애플리케이션.yml 파일을 사용하여 스프링 부트에서 로그 레벨을 구성할 수 있습니다. 다음은 그 방법입니다:

application.properties를 사용하는 방법:

```js
# 루트 로깅 레벨 설정
logging.level.root=INFO

# 특정 패키지에 대한 로깅 레벨 설정
logging.level.com.example=DEBUG
```

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

application.yml 파일을 사용하면:

```yaml
logging:
  level:
    root: INFO
    com.example: DEBUG
```

# 특정 로그 레벨 활성화 및 비활성화

특정 유형의 로그를 켜거나 제외하려면 구성 파일에서 로깅 수준을 조정할 수 있습니다. 몇 가지 예시는 다음과 같습니다:

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

DEBUG 로깅을 특정 패키지에 활성화하세요:

```js
logging.level.com.example = DEBUG;
```

이 설정은 com.example 패키지의 DEBUG, INFO, WARN 및 ERROR 로그가 출력될 것을 의미합니다.

TRACE 로그 제외:

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

```js
logging.level.com.example = INFO;
```

이 설정은 TRACE 로그가 출력되지 않지만 DEBUG, INFO, WARN 및 ERROR 로그는 출력됩니다.

# 예시 시나리오

- DEBUG 로깅 활성화:

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

```js
logging.level.com.example = DEBUG;
```

어떤 내용이 출력될까요?

- com.example 패키지에 대한 DEBUG, INFO, WARN 및 ERROR 메시지가 출력됩니다.

2. TRACE 로깅 활성화:

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

```js
logging.level.com.example = TRACE;
```

무엇이 출력됩니까?

- com.example 패키지에 대한 TRACE, DEBUG, INFO, WARN 및 ERROR 메시지가 출력됩니다.

3. 루트 로깅 레벨을 WARN으로 설정하기:

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

```js
logging.level.root = WARN;
```

어떻게 출력되나요?

- 특정 패키지에 대해 재정의되지 않는 한 전체 어플리케이션에서는 WARN 및 ERROR 메시지만 출력됩니다.

4. 서로 다른 패키지에 대한 서로 다른 로깅 수준:

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

```yaml
logging:
  level:
    root: WARN
    com.example.service: DEBUG
    com.example.controller: INFO
```

무슨 메시지가 출력되나요?

- 전체 애플리케이션에 대한 WARN 및 ERROR 메시지.
- com.example.service에 대한 DEBUG, INFO, WARN 및 ERROR 메시지.
- com.example.controller에 대한 INFO, WARN 및 ERROR 메시지.

# 스프링 부트에서 로그 레벨을 동적으로 변경하기

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

스프링 부트 액추에이터는 애플리케이션을 다시 시작하지 않고 로그 레벨을 동적으로 변경할 수 있는 방법을 제공합니다. 다음은 그 방법입니다:

- 액추에이터 종속성 추가:

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

2. 로거 엔드포인트 활성화:

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

```javascript
management.endpoints.web.exposure.include = loggers;
```

3. HTTP POST 요청을 통해 로그 레벨 변경:

```javascript
curl -X POST "http://localhost:8080/actuator/loggers/com.example" -H "Content-Type: application/json" -d '{"configuredLevel":"DEBUG"}'
```

- 이를 통해 com.example의 로깅 레벨이 DEBUG로 설정됩니다.

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

# 자바 Spring Boot에서 로깅하는 뛰어난 방법

- 일관된 형식 사용: 로그 메시지가 쉽게 구문 분석되도록 일관된 형식을 따르도록 합니다.

```js
logger.info("주문 ID: {}, 상태: {}", orderId, status);
```

- 구조화된 로깅 사용: 가능한 경우 구조화된 로깅을 사용하여 쉬운 구문 분석 및 검색을 가능하게 합니다.

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

```js
{
  "timestamp": "2024-08-06T12:34:56.789Z",
  "level": "INFO",
  "message": "주문이 성공적으로 처리되었습니다",
  "orderId": 12345,
  "status": "완료"
}
```

- 반복문 안에서 로그를 남기지 말기: 반복문 내에서 로그를 남기면 성능에 상당한 영향을 줄 수 있습니다.

```js
// 대신 반복문 내에서 로그를 남기지 말고 한 번에 집계하고 루프 외부에서 로그를 남깁니다.
```

- 적절한 수준에서 로깅: 로깅할 메시지에 적절한 로그 수준을 사용하여 혼란을 피하고 로그를 유지 관리하세요.

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

```js
logger.debug("methodX의 디버깅 정보: {}", details);
logger.warn("methodY에서 잠재적인 문제 발견");
```

- 로그 정기적으로 확인하기: 주기적으로 로그 문장들을 확인하여 여전히 관련성이 있고 유용한지 확인해보세요.

# 스프링 부트에서 로깅 예시

다음은 스프링 부트 애플리케이션에서 로깅을 설정하고 사용하는 실제 예시입니다.

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

- 로깅 의존성 추가: 스프링 부트는 기본적으로 Logback을 사용하므로 추가 의존성이 필요하지 않습니다.
- application.properties에서 로깅 레벨 구성:

```js
logging.level.root = INFO;
logging.level.com.example.myapp = DEBUG;
```

3. 코드에 로그 문 작성:

```js
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {
    private static final Logger logger = LoggerFactory.getLogger(MyController.class);

    @GetMapping("/hello")
    public String hello() {
        logger.info("Hello endpoint was called");
        try {
            // 비즈니스 로직
            logger.debug("비즈니스 로직이 성공적으로 실행되었습니다");
            return "Hello, World!";
        } catch (Exception e) {
            logger.error("안녕 엔드포인트 처리 중 오류가 발생했습니다", e);
            throw e;
        }
    }
}
```

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

그런데 제 최신 블로그 "자바 개발자가 하는 5가지 실수 (및 그것을 피하는 방법)"도 확인해보세요.

결론

효과적인 로깅은 모든 개발자에게 중요한 기술입니다. 이러한 모범 사례를 따르고 다양한 로그 수준의 사용 방법을 이해함으로써 로그가 유용하고 정보를 제공하며 과도하게 상세하지 않도록 할 수 있습니다. 전략적으로 로그를 남기고 정기적으로 로그를 검토하여 유용성을 유지하십시오.


자바 Spring Boot에서 로그문 사용 방법


## 메모리 관리와 가비지 콜렉션 마스터하기

알렉스와 조던은 노드.js 프로젝트에 깊게 몰두하던 중 뭔가 불안한 점을 발견했습니다 — 어느 정도의 시간 동안 애플리케이션을 실행한 후에는 점점 더 많은 메모리를 소비하다가 결국 무너지기 시작했습니다. 조던은 당황한 모습을 보였지만, 경험이 풍부한 알렉스는 즉시 메모리 누수를 의심했습니다. "효율적인 코드를 작성하는 것 이상의 문제입니다," 알렉스가 설명했습니다. "이는 Node.js가 메모리를 처리하는 방식을 이해하고 가비지 콜렉터를 만족시키는 방법을 알아야 합니다."

## 1. V8의 메모리 관리 이해하기

Node.js는 자체의 메모리 관리 및 가비지 콜렉션 메커니즘을 갖춘 V8 JavaScript 엔진을 사용합니다. 그러나 Node.js의 단일 스레드 특성으로 인해 메모리 관리에 특별한 주의가 필요합니다. V8 엔진은 메모리를 주로 힙(heap) 및 스택(stack) 두 가지 주요 영역에 할당합니다. 스택은 정적 메모리 할당을 다루고, 힙은 동적 메모리 할당에 사용됩니다.

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

경험이 있는 개발자들은 힙(heap)이 가장 많은 메모리 문제가 발생하는 곳임을 알고 있습니다. Node.js에서 힙은 제한된 크기를 가지고 있으며, 일반적으로 64비트 시스템에서는 약 1.5GB에서 4GB 사이입니다. 이 한도를 초과하면 메모리 부족 오류가 발생하여 응용 프로그램이 다운될 수 있습니다.

## 2. 메모리 누수 식별과 방지

Node.js에서 메모리 누수는 할당된 메모리가 더 이상 필요하지 않지만 해제되지 않아 시간이 지남에 따라 메모리 사용량이 계속 증가하는 경우에 발생합니다. 여기에는 일반적인 원인 몇 가지와 이를 방지하는 방법이 있습니다:

- 전역 변수: 변수가 의도하지 않게 전역에 저장될 때 메모리 누수가 발생하기 쉽습니다. 변수를 항상 "let", "const", 또는 "var"로 선언하여 전역 범위로 누출되지 않도록 주의하십시오.
- 클로저: 외부 함수에서 변수에 대한 참조를 보유하는 클로저는 해당 참조가 정리되지 않을 경우 메모리 누수를 초래할 수 있습니다. 오랜 기간 사용되는 클로저를 주의 깊게 관리하세요.
- 이벤트 리스너: 제거되지 않은 이벤트 리스너는 쌓이며, 가비지 수집되어야 할 객체에 대한 참조를 보유합니다. "removeListener" 또는 "off"로 항상 리스너를 정리하세요.

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

아래는 Markdown 형식의 표입니다.

| Syntax    | Description |
| --------- | ----------- |
| Header    | Title       |
| Paragraph | Text        |

위의 예시에서 첫 번째 예시는 메모리 누수를 발생시키는 클로저로 인한 타이머를 시작합니다. 두 번째 예시는 작업이 완료된 후 정확한 정리를 보여줍니다.

## 3. 가비지 컬렉션: 효율적으로 유지하기

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

Node.js에서의 가비지 수집은 자동적이지만 그 특이한 면도 있어요. V8 엔진은 세대별 가비지 수집기를 사용해서 메모리를 새로운 공간(젊은 세대)과 오래된 공간(늙은 세대) 두 부분으로 나누어요. 여러 차례의 가비지 수집을 버티는 객체들은 오래된 공간으로 승격돼요.

이러한 접근 방식은 효율적이지만 제대로 관리하지 않으면 성능 문제로 이어질 수 있어요. 예를 들면, 객체들이 많이 생성되면 빈번한 가비지 수집을 유발해 실행 코드보다 가비지 수집에 더 많은 시간을 쓰게 되는 GC thrashing 현상이 발생할 수 있어요.

코드 예시:

```js
const data = [];
function addData() {
  for (let i = 0; i < 1e6; i++) {
    data.push({ item: i }); // 쉽게 많은 객체를 생성해냄
  }
}
addData();
```

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

이 예제에서는 수백만 개의 객체가 빠르게 생성되어 GC 스래싱으로 이어질 수 있습니다. 더 나은 접근 방식은 더 작은 일괄 처리로 객체를 생성하고 폐기하거나 대규모 데이터셋을 관리하는 더 효율적인 데이터 구조를 사용하는 것입니다.

## 결론

메모리 관리와 가비지 수집은 초보 개발자에 의해 종종 간과되지만, 이러한 기술은 확장 가능하고 효율적인 Node.js 애플리케이션을 개발하려는 사람들에게 필수적입니다. V8가 메모리를 할당하는 방법을 이해하고 메모리 누수의 일반적인 원인을 인식하며 가비지 수집을 최적화하는 것은 애플리케이션이 우아하게 확장되는지 또는 부하 하에서 충돌하는지의 차이를 만들어 줄 수 있습니다.

다음 시리즈에서는 Node.js에서 비동기 작업을 최적화하는 고급 기술들을 탐색할 것입니다. 백프레셔를 관리하고 워커 스레드를 효과적으로 사용하는 것을 포함합니다. 기대해 주세요!


2024년 최신 Nodejs 핵심 개념 정리


## CRUD 애플리케이션을 위한 요청 유효성 검증 기술 간소화

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

# JOI란 무엇인가요?

JOI는 데이터 유효성 검사를 간편하게 만드는 JavaScript 라이브러리입니다. 양식, API 요청 또는 다른 데이터 소스로부터의 사용자 입력일 경우 JOI를 사용하면 검증 규칙을 쉽게 정의하고 적용할 수 있습니다. 들어오는 데이터가 깨끗하고 안전한지 보장하여 JOI는 잘못된 또는 악의적인 입력에 의해 발생하는 예기치 않은 문제로부터 응용 프로그램을 보호합니다.

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

# JOI의 일반적인 사용 방법

가정해 보겠습니다. 사용자가 응용 프로그램에 로그인하기 위해 다음 자격 증명을 입력했다고 가정해 봅시다:

```js
{
  email: "myemail00@xyz.com",
  password: "This_Is_My_Password11"
}
```

이제 응용 프로그램을 통해 사용자가 입력한 이메일과 비밀번호를 유효성 검사해야 하는데, 다음은 여러분의 요구 사항입니다:

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

- 이메일:
  — ‘String’ 으로 지정되어야 함
  — 최소 5자 이상 최대 255자
  — 비어 있을 수 없음, 필수 필드임
  — 유효한 이메일 형식이어야 함 (즉, ‘@’, ‘.com’ 등이 포함되어 있어야 함)
- 비밀번호
  — ‘String’ 으로 지정되어야 함
  — 최소 5자 이상 최대 255자
  — 비어 있을 수 없음, 필수 필드임

## 수동 확인

일반적인 시나리오에서 라이브러리를 사용하지 않고, 각 개별 엔티티에 대해 이러한 조건이 충족되는지 수동으로 확인하는 함수를 만들어야 합니다. 이 함수는 다음과 같이 보일 수 있습니다:

```js
function validateUser(user) {
  const errors = {};

  // 이메일이 존재하고 문자열이며 5자에서 255자 사이의 길이를 가지고 있는지, 유효한 이메일 형식인지 확인
  if (!user.email || typeof user.email !== "string") {
    errors.email = "이메일은 필수이며 문자열이어야 합니다.";
  } else if (user.email.length < 5 || user.email.length > 255) {
    errors.email = "이메일은 5자에서 255자 사이여야 합니다.";
  } else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(user.email)) {
    errors.email = "유효한 이메일 주소여야 합니다.";
  }

  // 비밀번호가 존재하고 문자열이며 5자에서 255자 사이의 길이를 가지고 있는지 확인
  if (!user.password || typeof user.password !== "string") {
    errors.password = "비밀번호는 필수이며 문자열이어야 합니다.";
  } else if (user.password.length < 5 || user.password.length > 255) {
    errors.password = "비밀번호는 5자에서 255자 사이여야 합니다.";
  }

  // 오류를 발견하지 못했을 경우 null 반환
  return Object.keys(errors).length === 0 ? null : errors;
}
```

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

이 방법은 긴, 번잡하고 확장 가능하지 않습니다. 더 쉽고 훨씬 더 확장 가능한 방법은 JOI 검증 라이브러리를 사용하는 것입니다.

## JOI를 활용한 확인(아주 쉬워요)

JOI를 사용하려면 먼저 JOI 패키지를 설치한 다음 JOI 라이브러리를 가져와야 합니다. 설치를 위해 터미널에서 다음 명령을 실행하세요:

- npm install joi

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

지금 다음 명령어를 사용하여 JS 파일에서 JOI 모듈을 가져오세요:

```js
const Joi = require("joi");
```

이제 위에 작성된 함수를 간단히 다음 JOI 함수로 대체할 수 있습니다:

```js
function validateUser(user) {
  const schema = {
    email: Joi.string().min(5).max(255).required().email(),
    password: Joi.string().min(5).max(255).required(),
  };

  return Joi.validate(user, schema);
}
```

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

단순화된 것이 분명히 보입니다. 이 예시에서는 매우 적은 JOI 체크만 사용되었지만 min(x), max(y), required(), int(), string(), alphanum() 등 많은 다른 체크가 있습니다.

이런 명령어들은 문서 사이트에서 확인할 수 있어요: [https://joi.dev/api/?v=17.13.3](https://joi.dev/api/?v=17.13.3)

## Joi.validate( obj , schema ) function

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

위의 리턴문에서 검사되는 것은 입력된 객체를 정의된 스키마와 비교하며, 불리언 값이 아닌 두 가지 주요 속성이 있는 객체를 반환합니다:

- `error`:
  유효성 검사에 실패하면 이 속성에는 유효성 검사 실패를 설명하는 오류 객체가 포함됩니다. 유효성 검사에 성공하면 이 속성은 `null`입니다.
- `value`:
  유효성 검사에 성공하면 이 속성에는 정리되고 유효성이 검사된 데이터가 포함됩니다. 유효성 검사에 실패하면 이 속성은 `undefined`입니다.

따라서 반환된 객체의 `error` 속성을 검사하여 유효성 검사가 성공했는지 실패했는지 확인할 수 있습니다. `error`가 `null`이면 유효성 검사가 성공했습니다. `error`가 `null`이 아닌 경우에는 유효성 검사가 실패했으며, `error.details`를 사용하여 오류 세부 정보에 액세스할 수 있습니다.

# CRUD 애플리케이션에서 무엇을 유효성 검사해야 하는가?

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

CRUD 애플리케이션에서 각 HTTP 요청 유형은 고유한 목적을 제공하며 특정한 특성을 가지고 있습니다. 따라서 JOI를 사용한 요청 유효성 검사는 해당 내용에 맞게 설정되어야 합니다. 다음 표에서는 각 요청 유형에서 어떤 부분을 검증해야 하는지 안내합니다:

![JOIValidationinNodeJSExpressJS_1](/assets/img/2024-08-19-JOIValidationinNodeJSExpressJS_1.png)

## GET(Read) 요청

- Headers: ✅
  엔드포인트를 안전하게 유지하고 무단 액세스를 제한하기 위해 GET 요청의 헤더를 확인하여 요청이 승인되었고 합법적인 소스에서 온 것임을 보장합니다.
- Body: ❌
  보통 GET 요청에는 요청 본문이 포함되지 않습니다. 데이터를 보내는 대신 데이터를 검색하는 데 사용되기 때문에 이 경우 일반적으로 본문을 검증할 필요가 없습니다.

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

다음은 JOI를 사용하여 GET 요청을 유효성 검사하는 예제입니다:

```js
app.get("/get-user/:id", (req, res) => {
  // 요청 헤더 유효성 검사
  const { error: headerError } = headerSchema.validate(req.headers);
  if (headerError) {
    return res.status(400).json({ error: headerError.details[0].message });
  }

  // URL 매개변수 유효성 검사 (요청에 'id'가 포함되어 있는 경우)
  const paramSchema = Joi.string().guid();
  const { error: paramError } = paramSchema.validate(req.params.id);
  if (paramError) {
    return res.status(400).json({ error: paramError.details[0].message });
  }

  // 요청 처리
  // ...
});
```

## POST (생성) 요청

- 헤더: ✅
  GET 요청과 유사하게, POST 요청에서는 권한 및 보안을 위해 헤더를 유효성 검사할 수 있습니다.
- 본문: ✅
  POST 요청에서는 일반적으로 새로운 리소스를 생성하는 데 사용할 데이터가 요청 본문에 포함됩니다. 요청 본문을 유효성 검사하면 새 리소스를 생성하기 전 제공된 데이터가 예상 형식과 제한에 부합하는지 확인할 수 있습니다.

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

다음은 POST 예시입니다:

```js
app.post("/create-user", (req, res) => {
  // 요청 헤더 유효성 검사
  const { error: headerError } = headerSchema.validate(req.headers);
  if (headerError) {
    return res.status(400).json({ error: headerError.details[0].message });
  }

  const userSchema = Joi.object({
    username: Joi.string().alphanum().min(3).max(30).required(),
    email: Joi.string().email().required(),
    age: Joi.number().integer().min(18).max(99),
  });

  // 요청 본문 유효성 검사
  const { error } = userSchema.validate(req.body);
  if (error) {
    return res.status(400).json({ error: error.details[0].message });
  }

  // 요청 처리 및 새로운 사용자 생성
  // ...
});
```

## PUT (수정) 요청

- 헤더: ✅
  GET 및 POST 요청과 마찬가지로, PUT 요청에서는 헤더를 유효성 검사하여 권한과 보안을 확인할 수 있습니다.
- 본문: ✅
  PUT 요청에서는 일반적으로 요청 본문에 기존 리소스의 업데이트된 데이터가 포함됩니다. 헤더와 본문 모두 유효성을 검사하면 요청이 인가되었으며 업데이트된 데이터가 필요한 형식과 제약 조건을 준수하는지 확인할 수 있습니다.

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

다음은 PUT에 대한 예시입니다:

```js
app.put("/update-user/:id", (req, res) => {
  // 요청 헤더 유효성 검사
  const { error: headerError } = headerSchema.validate(req.headers);
  if (headerError) {
    return res.status(400).json({ error: headerError.details[0].message });
  }

  // URL 매개변수 유효성 검사
  const { error: paramError } = Joi.string().guid().validate(req.params.id);
  if (paramError) {
    return res.status(400).json({ error: paramError.details[0].message });
  }

  // 사용자 업데이트를 위한 요청 본문 유효성 검사
  const updateUserSchema = Joi.object({
    username: Joi.string().alphanum().min(3).max(30),
    email: Joi.string().email(),
    age: Joi.number().integer().min(18).max(99),
  });

  const { error: bodyError } = updateUserSchema.validate(req.body);
  if (bodyError) {
    return res.status(400).json({ error: bodyError.details[0].message });
  }

  // 요청 처리 및 사용자 업데이트
  // ...
});
```

## DELETE 요청

- 헤더: ✅
  기타 요청 유형과 마찬가지로, DELETE 요청에서도 헤더를 유효성 검사할 수 있어서 권한이 있는 요청만 처리되도록 할 수 있습니다.
- 본문: ❌
  일반적으로 DELETE 요청은 URL에 의해 식별된 리소스를 삭제하는 것이 목적이기 때문에 요청 본문이 필요하지 않습니다. 따라서 DELETE 요청에서 본문을 유효성 검사할 필요가 거의 없습니다.

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

다음은 DELETE 요청에 대한 예시입니다:

```js
app.delete("/delete-user/:id", (req, res) => {
  // 요청 헤더 유효성 검사
  const { error: headerError } = headerSchema.validate(req.headers);
  if (headerError) {
    return res.status(400).json({ error: headerError.details[0].message });
  }

  // URL 매개변수 유효성 검사
  const { error: paramError } = Joi.string().guid().validate(req.params.id);
  if (paramError) {
    return res.status(400).json({ error: paramError.details[0].message });
  }

  // 요청 처리 및 사용자 삭제
  // ...
});
```

## 결론

이 방법의 목표는 CRUD 작업에서 데이터 무결성, 보안 및 일관성을 보호하는 것입니다. 요청 헤더를 유효성 검사함으로써, 인가된 요청만 의도한 작업을 수행할 수 있도록 보장합니다. 반면에 요청 본문을 검증하면, 데이터가 처리되거나 데이터베이스 작업에 의해 추가로 처리되기 전에 데이터가 예상대로 충족되는지 확인함으로써 오류를 방지하고 애플리케이션을 취약점으로부터 보호하는 역할을 합니다.

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

JOI는 직관적인 인터페이스를 제공하여 전체 유효성 검사 프로세스를 간단하게 만들어줍니다. 애플리케이션이 발전함에 따라 유효성 규칙을 조정하고 업데이트하기가 쉬워집니다. 앱이 성장하고 필요 사항이 변화할 때, JOI를 사용하여 검사를 손쉽게 정제하여 모든 것을 일관되고 안전하게 유지할 수 있습니다.


NodeJS와 ExpressJS에서 JOI 유효성 검사 사용하기


## API Gateway 아키텍쳐 기본 개념 이해하기

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

API Gateway는 현대적인 마이크로서비스 아키텍처의 중요한 부분입니다. 이는 모든 클라이언트 요청의 진입점 역할을 하며, 이들을 관리, 유효성 검사, 방지 및 적절한 서비스로 라우팅하는 역할을 합니다. 이 시리즈에서는 API Gateway의 중요한 부분에 초점을 맞추어 Node.js로 구현하는 방법을 살펴볼 것입니다. 이번 파트에서는 API Gateway의 개요를 제공하고, 이점과 단점을 논의하며, 나만의 API Gateway 솔루션에서 라우팅 구성요소를 구현하는 데 초점을 맞출 것입니다.

# 개요

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

API Gateway는 모든 클라이언트 요청의 진입점으로 작동하는 서버입니다. 다음과 같은 역할을 수행할 수 있습니다:

- 라우팅: 요청 경로, 메소드, 헤더, 그리고 기타 매개변수에 기반하여 들어오는 클라이언트 요청을 올바른 마이크로서비스로 라우팅합니다.
- 보안: 인증 및 권한 부여와 같은 특정 보안 정책을 시행할 수 있어 허가된 클라이언트만 특정 서비스나 엔드포인트에 액세스할 수 있도록 보장합니다.
- 속도 제한: 클라이언트가 주어진 기간에 할 수 있는 요청 수를 제한하여 마이크로서비스가 너무 많은 요청으로 과부하되는 것을 방지합니다.
- 캐싱: 마이크로서비스로부터의 응답을 캐시하여 반복 요청을 처리할 필요가 줄어들게 합니다.
- 모니터링 및 로깅: 만들어진 API 호출에 대한 상세한 모니터링 및 로깅을 제공하여 사용 패턴, 성능 및 마이크로서비스의 건강 상태에 대한 귀중한 통찰력을 제공합니다.

API Gateway를 사용하는 몇 가지 이점을 소개하자면:

- 간소화된 클라이언트 통신: 여러 서비스와 통신하는 대신 클라이언트는 API Gateway와만 통신하므로 통합 복잡성이 줄어듭니다.
- 중앙화된 보안: 인증 및 권한이 하나의 곳에 구현되므로 새로운 정책을 관리하기가 더 쉬워집니다.
- 서비스 추상화: API Gateway는 백그라운드 서비스의 복잡성을 숨기며 개별 서비스의 수정 및 업그레이드를 더 쉽게 만듭니다.
- 프로토콜에 중립적: 백그라운드 서비스는 다양한 프로토콜(예: GraphQL, gRPC)을 사용하여 통신할 수 있지만 API Gateway는 통합 프로세스를 간소화하는 통일된 HTTP API를 제공합니다.

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

하지만 API 게이트웨이에는 몇 가지 단점이 있습니다:

- 단일 장애 지점: API 게이트웨이가 실패하면 전체 API 서비스가 중단될 수 있습니다.
- 지연 시간 증가: 요청-응답 경로에 추가 계층을 추가하면 지연 시간이 발생할 수 있습니다.
- 개발 부담: 사용자 정의 라우팅, 보안 및 기타 정책을 개발하는 데 상당한 노력과 전문 지식이 필요할 수 있습니다.

그러므로 고가용성, 확장성 및 API 게이트웨이의 탄성을 보장하기 위해 특별한 아키텍처적 방법을 적용해야 합니다. 이는 여러분이 노출하는 API의 중심 구성 요소로써 중요합니다.

자체 API 게이트웨이를 개발하는 개발 부담을 처리할 준비가 되지 않았다면 다음 제품 중 하나를 사용하는 것을 고려해 볼 수 있습니다:

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

- AWS API Gateway: 사용자가 어떤 규모에서도 API Gateway를 생성, 유지 및 게시할 수 있는 관리형 아마존 웹 서비스;
- Kong: 균형 조정, 모니터링, 로깅 및 인증을 제공하는 오픈 소스 API Gateway 및 서비스 관리 도구;
- Nginx: API Gateway로 사용될 수 있는 고성능 오픈 소스 웹 서버;
- Traefik: API Gateway로 사용될 수도 있는 HTTP 역방향 프록시 및 로드 밸런서.

API Gateway가 어떻게 작동하는지 보여주기 위해 다양한 기능을 보여주는 간단한 구현을 만들 것입니다. 먼저 API Gateway의 주요 책임에 집중하여 시작하겠습니다: 라우팅.

# 라우팅

API Gateway로 들어오는 트래픽은 다양한 마이크로서비스로 라우팅되어야 하며, 이것이 API Gateway의 주요 책임입니다. 들어오는 트래픽을 올바르게 라우팅하는 방법을 파악하려면 API Gateway에 구성이 필요합니다. API Gateway를 구성하는 두 가지 옵션이 있습니다:

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

- 정적 구성: JSON 또는 YAML과 같은 형식의 파일로 구성을 제공합니다.
- 동적 구성: 이 방식은 API 게이트웨이가 데이터베이스나 일부 중앙 집중형 서비스(예: 서비스 검색)에서 실시간으로 구성을 가져올 수 있도록 합니다.

동적 구성은 자주 변경되는 환경에서 유용합니다. 그러나 API 게이트웨이 개발에서 추가 복잡성과 성능 오버헤드가 발생할 수 있습니다. API 게이트웨이는 정기적으로 구성 변경을 가져와 적용해야 하기 때문입니다.

간단하게 하기 위해 API 게이트웨이 라우팅 구성에는 간단한 JSON 파일을 사용할 것입니다.

Webpack의 프록시 구성에 영감을 받아 다음과 같은 API 게이트웨이 구성을 정의했습니다:

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

```js
[
  {
    name: "user-service",
    context: ["/users"],
    target: "http://localhost:3001",
    pathRewrite: {},
  },
];
```

구성은 라우트 배열입니다. 각 라우트에는 다음과 같은 속성이 있습니다:

- name: 추적 목적으로 사용될 수 있는 라우트의 고유 식별자;
- context: API 게이트웨이가 청취할 특정 라우트의 비어 있지 않은 배열. URL이 /users로 시작하는 요청이 수신되면 API 게이트웨이는 해당 대상 서비스로 라우팅합니다;
- target: 지정된 context와 일치하는 요청을 API 게이트웨이가 전달해야 하는 백엔드 서비스 URL을 정의합니다;
- pathRewrite: 속성을 사용하여 요청 URL 경로를 대상 서비스로 전달하기 전 수정할 수 있습니다. 구성이 빈 객체('')로 정의되면 변환이 필요하지 않음을 의미합니다. 그러나 구성 '‘^/test’: ‘/api’,'는 경로 /test를 /api로 대체한다는 것을 의미합니다.

Node.js로 API 게이트웨이를 구현하기 위해 Express 웹 서버를 사용할 것입니다. Express 웹 서버는 유연하고 간단하며 강력한 웹 서버로서 API 게이트웨이를 구축하는 완벽한 선택입니다.

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

설정에 따라 API Gateway는 구성 파일에 정의된 특정 경로만 수신할 수 있습니다. 그러나 모든 수신 트래픽을 수신하도록 구성할 것입니다. 구성 파일에 정의되지 않은 경로의 경우, Gateway는 설명과 함께 404 Not Found 응답을 반환할 것입니다.

들어오는 요청 핸들러를 개발해보겠습니다:

```js
const fetch = require("node-fetch");

const routes = require("../routes/routes.json");

const errors = {
  ROUTE_NOT_FOUND: "ROUTE_NOT_FOUND",
};

const defaultTimeout = parseInt(process.env.HTTP_DEFAULT_TIMEOUT) || 5000;
const nonBodyMethods = ["GET", "HEAD"];

/**
 * @typedef {import('node-fetch').Response} Response
 * @typedef Result
 * @property {string} error
 * @property {string} message
 * @property {Response} response
 */

/**
 * 요청을 해당 서비스로 프록시하는 메서드
 * @typedef {import('express').Request} Request
 * @param {Request} req
 * @returns {Promise<Result>}
 */
async function handler(req) {
  const { path, method, headers, body, ip } = req;

  const route = routes.find((route) => route.context.some((c) => path.startsWith(c)));
  if (!route) {
    return {
      error: errors.ROUTE_NOT_FOUND,
      message: "경로를 찾을 수 없음",
    };
  }

  const servicePath = Object.entries(route.pathRewrite).reduce(
    (acc, [key, value]) => acc.replace(new RegExp(key), value),
    path
  );

  const url = `${route.target}${servicePath}`;
  const reqHeaders = {
    ...headers,
    "X-Forwarded-For": ip,
    "X-Forwarded-Proto": req.protocol,
    "X-Forwarded-Port": req.socket.localPort,
    "X-Forwarded-Host": req.hostname,
    "X-Forwarded-Path": req.baseUrl,
    "X-Forwarded-Method": method,
    "X-Forwarded-Url": req.originalUrl,

    "X-Forfarded-By": "api-gateway",
    "X-Forwarded-Name": route.name,
    "X-Request-Id": req.id,
  };

  const reqBody = nonBodyMethods.includes(method) ? undefined : body;

  const response = await fetch(url, {
    method,
    headers: reqHeaders,
    body: reqBody,
    follow: 0,
    timeout: route?.timeout || defaultTimeout,
  });

  return {
    response,
  };
}

module.exports = handler;
module.exports.errors = errors;
```

핸들러의 첫 단계는 들어오는 경로와 일치하는 구성을 찾는 것입니다. 구성에서 경로가 정의되지 않은 경우 오류가 반환됩니다. 그 후에 다른 핸들러(나중에 보여드리겠습니다)가 사용자에게 404 Not Found 응답을 전송할 것입니다.

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

API Gateway는 다음으로 패스 리라이트 규칙을 적용하고 HTTP 요청을 대상 서비스로 전달하기 위해 준비합니다. 이 과정에서 API Gateway는 또한 프록시 컨텍스트를 정의하는 사용자 정의 헤더를 추가합니다. 이러한 헤더에는 클라이언트의 IP 주소와 대상 서비스에서 필요한 기타 메타데이터와 같은 원본 요청에 대한 정보가 포함될 수 있습니다.

대상 서비스가 반환한 HTTP 응답은 Express 요청 핸들러로 반환됩니다:

```js
const service = require("../services/proxy");

/**
 * 프록시 핸들러
 * @typedef {import('express').Request} Request
 * @typedef {import('express').Response} Response
 * @typedef {import('express').NextFunction}
 * @param {Request} req
 * @param {Response} res
 * @returns {void}
 */
module.exports = async (req, res, next) => {
  try {
    const { error, message, response } = await service(req);

    if (error) {
      if (error === service.errors.ROUTE_NOT_FOUND) {
        res.status(404).json({ error, message }).send();
      } else {
        res.status(500).json({ error, message }).send();
      }

      return;
    }

    res.status(response.status);
    response.headers.forEach((value, key) => res.setHeader(key, value));

    const content = await response.buffer();
    res.send(content);
  } catch (err) {
    next(err);
  }
};
```

에러가 반환되면 핸들러가 분석하여 적절한 응답을 최종 사용자에게 보내고, 그렇지 않으면 대상 서비스로부터의 응답을 최종 사용자에게 전달합니다.

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

처음에는 다음과 같은 중간 처리기들도 구현했습니다:

- 에러 핸들러: 이 처리기는 요청 처리 중에 발생하는 모든 오류를 로그에 기록합니다.
- 로거: 이 처리기는 들어오는 트래픽에 대한 정보를 로그에 남깁니다.
- 요청 ID: 이 처리기는 각 들어오는 요청에 추적을 위한 고유 식별자를 추가합니다.

API 게이트웨이는 JSON만 처리하는 것으로 제한되지 않습니다. XML, HTML, 일반 텍스트 및 이진 데이터와 같은 여러 데이터 형식을 수락하고 반환할 수도 있습니다. API 게이트웨이가 모든 콘텐츠 유형과 작동하도록 하기 위해 Express의 raw 처리기를 구성했습니다.

게다가, 프록시 핸들러에 유닛 테스트를 적용하여 신뢰성과 정확성을 보장했습니다. 또한 GitHub Actions를 사용한 CI 프로세스를 구현하여 테스트를 자동화했습니다. 이 설정을 통해 코드베이스에 대한 모든 변경 사항이 자동으로 테스트되어 코드 품질을 유지할 수 있습니다.

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

API Gateway를 테스트하기 위해 간단한 사용자 서비스를 구현했습니다:

```js
const express = require("express");

const app = express();

const users = [];

app.use(express.json());

app.get("/users/:id", (req, res) => {
  const id = req.params.id;
  const user = users.find((user) => user.id === id);
  res.json(user);
});

app.post("/users", (req, res) => {
  const user = req.body;
  users.push(user);
  res.json(user);
});

app.listen(3001, () => {
  console.log("Server is running on port 3001");
});
```

다음 요청을 실행하면 API Gateway를 통해 사용자 서비스에 접속할 수 있습니다:

```js
curl --location 'localhost:3000/users' \
--header 'Content-Type: application/json' \
--data '{
    "id": "42",
    "name": "Dmytro"
}'

curl --location 'localhost:3000/users/42'
```

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

# 어플리케이션 코드

다음 저장소에서 어플리케이션 코드를 찾을 수 있어요:

좋아하시면 저장소를 스타(star)해 주세요!

# 저를 지원하기

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

만약 제 글에서 기쁨이나 가치를 찾았고 감사의 표시를 하고 싶다면, 이제 'Buy Me A Coffee'로 기부할 수 있습니다! 여러분의 지원은 더 많은 이야기, 통찰력, 그리고 여러분과 공감하는 콘텐츠를 계속 공유할 수 있도록 돕는 데 큰 도움이 될 것입니다.

# 결론

API Gateway는 모던 마이크로서비스 개발에서 중요한 역할을 합니다. 모든 클라이언트의 들어오는 트래픽을 단일 진입점으로 작용하여 적절한 서비스로 라우팅하고 보안 및 비율 제한과 같은 여러 가지 중요한 측면들을 관리합니다.

이 글에서는 Node.js와 Express를 사용하여 API Gateway를 개발하기 시작했습니다. 미들웨어와 적절한 구성을 활용하여, 클라이언트가 백엔드 서비스와 상호작용을 단순화하는 유연하고 확장 가능한 게이트웨이를 만들었습니다. 또한 단위 테스트와 CI 프로세스를 구현함으로써 API Gateway가 신뢰할 수 있고 높은 코드 품질을 유지할 수 있도록 보장했습니다.

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

향후 게시물에서는 보안, 모니터링, 속도 제한 등과 같은 API 게이트웨이의 다른 측면을 탐구할 예정입니다. 노드.js를 활용한 API 게이트웨이 개발을 숙달하는 데 도움이 되는 통찰력과 실용적인 예제를 더 알아보세요.


Nodejs로 API 게이트웨이 구축하기 - 개요, 라우팅


![이미지](/assets/img/2024-08-19-CreateaFIFOReal-timeNotificationsSystemWithRedisBullAndSocketIoInNodeJSBackend_0.png)

백엔드 시스템 개발에서 때로는 간단한 비동기 접근만으로 충분하지 않을 때가 있습니다. 티켓 판매나 제한된 재고 캠페인과 같이 구매 요청을 처리하기 전에 상품 재고를 확인해야 하는 시스템에서는 FIFO(선입선출) 시스템이 필수적입니다. 이러한 경우 사용자에게 보류 중인 응답을 보내주고, 상태 변경에 대한 실시간 알림을 제공해야 합니다. 상태가 허용되었는지 아니면 재고 소진과 같은 이유로 거부되었는지 알려줘야 합니다.

알림을 위한 다양한 방법이 있지만, 이 경우에는 Socket IO를 사용하여 프론트엔드 또는 사용자에게 실시간 업데이트를 보냅니다. 대기열을 관리하기 위해 Redis와 Bull을 사용하고 있습니다.

그럼, 시작해봅시다!

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

서버 설정

먼저 터미널을 열고 다음 명령을 사용하여 nodejs-queue라는 폴더(또는 원하는 다른 이름)를 만드세요:

```js
mkdir nodejs-queue
```

다음 명령을 사용하여 package.json 파일을 만드세요:

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

```js
npm init -y
```

그런 다음 몇 가지 패키지를 설치하세요.

```js
npm install --save express redis cors socket.io bull
```

개발 환경에서는 Nodemon을 사용하여 개발 프로세스를 간단하게 만들어요. 백엔드에서는 업데이트를 하면 자동으로 다시 시작해요.

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

npm install -D nodemon

루트 폴더에 app.js 파일을 생성한 후 package.json 스크립트에 다음을 추가하세요.
“dev”: “nodemon app.js”, 그리고 package.json에도 type: module을 추가해주세요.

다음은 변경된 package.json 파일입니다.

```json
{
  "name": "nodejs-queue",
  "version": "1.0.0",
  "description": "",
  "main": "app.js",
  "scripts": {
    "dev": "nodemon app.js"
  },
  "type": "module",
  "keywords": [],
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "nodemon": "^3.1.4"
  },
  "dependencies": {
    "bull": "^4.16.0",
    "cors": "^2.8.5",
    "express": "^4.19.2",
    "redis": "^4.7.0",
    "socket.io": "^4.7.5"
  }
}
```

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

app.js에 서버를 설정하세요.

```js
import express from "express";
import cors from "cors";
import http from "http";

const app = express();

const server = http.createServer(app);
const PORT = 3000;

const MyServer = async () => {
  try {
    app.use(cors());
    app.use(express.urlencoded({ extended: false }));
    app.use(express.json());
    server.listen(PORT, () => console.log(`서버가 포트 ${PORT}에서 실행 중입니다.`));
  } catch (error) {
    throw Error(error);
  }
};

MyServer();
```

그런 다음 터미널에서 "npm run dev"를 실행하세요. 올바르게 실행하면 이렇게 보일 것입니다.

![이미지](/assets/img/2024-08-19-CreateaFIFOReal-timeNotificationsSystemWithRedisBullAndSocketIoInNodeJSBackend_1.png)

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

FIFO 시스템 생성하기

이제 FIFO 기반의 구매 시스템을 만들어보겠습니다. 판매되는 상품은 재고가 5개뿐입니다. 사용자가 구매를 하면 먼저 요청이 처리 중이라는 메시지를 받게 됩니다. 재고가 아직 있는 경우, 요청이 수락된 것을 알리는 알림을 보내줍니다. 그러나 재고가 소진된 경우, 품절 상태인 것을 알리는 알림을 전송합니다.

우선은 Bull & Redis를 설정해야 합니다. queue.js라는 파일을 생성하고 다음 코드를 추가해주세요.

```js
import Queue from "bull";

export const MyQueue = new Queue("my-queue", {
  redis: {
    host: "127.0.0.1",
    port: 6379,
  },
});

function delay(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

let stock = 5;

MyQueue.process(async (job) => {
  await delay(5000);
  console.log(job.data);
});
```

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

제품 데이터베이스의 수량을 시뮬레이션하는 재고 변수를 만들었습니다. 또한 비동기 프로세스를 시뮬레이션하는 지연 함수도 만들었습니다.

이제 코드를 테스트할 준비가 되었습니다. app.js에 MyQueue를 import하세요.

```js
import { MyQueue } from "./queue.js";
```

MyServer 함수에 다음 코드를 추가하세요.

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

```js
app.get("/test", async (_, res) => {
  MyQueue.add({ message: "hello world" });
  res.status(200).json({ message: "Your order is in queue." });
});
```

Postman이나 브라우저를 열고 이 URL을 복사하세요.

```js
http://localhost:4000/buy
```

터미널에서 이 것을 보면 제대로 작성한 것입니다.

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

아래는 마크다운 형식으로 표로 변환한 내용입니다.

![이미지](/assets/img/2024-08-19-CreateaFIFOReal-timeNotificationsSystemWithRedisBullAndSocketIoInNodeJSBackend_2.png)

이제 사용자에게 요청 상태에 대한 정보를 제공하기 위해 Socket.io를 설정해야 합니다.

app.js에 Socket Io를 가져와 다음 코드를 추가하세요.

```js
import { Server } from "socket.io";

export const Io = new Server(server, {
  cors: {
    origin: "*",
  },
});
```

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

다음으로, queue.js 파일에 Io 변수를 가져오세요.

```js
import { Io } from "./app.js";
```

이제 app.js에 POST 라우트를 만들어서 이메일을 body로 받는 로직을 추가합니다.

```js
app.post("/buy", async (req, res) => {
  let email = req.body.email;
  if (!email) throw Error("Required Email");
  MyQueue.add({ data: { email } });
  res.status(200).json({ message: "주문이 처리되었습니다" });
});
```

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

나중에 특정 사용자에게 메시지를 보내는 '키'로이 이메일도 사용할 것입니다.

게다가, 재고를 검증하는 미들웨어를 생성할 수도 있습니다. 따라서 재고가 소진되면 대기열 처리를 계속하지 않을 것입니다.

아래 코드를 app.js에 추가해주세요.

```js
const ValidateStock = (_, res, next) => {
  if (stock > 1) return next();
  else res.status(400).json({ message: "죄송합니다, 재고가 소진되었습니다" });
};
```

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

"Buy" 엔드포인트에 그 미들웨어를 추가해주세요.

```js
app.post("/buy", ValidateStock, async (req, res) => {
  let email = req.body.email;
  if (!email) throw Error("Required Email");
  MyQueue.add({ data: { email } });
  res.status(200).json({ message: "주문이 처리되었습니다" });
});
```

이제 이를 프론트엔드에서 테스트하여 소켓 IO가 올바르게 실행되었는지 확인합니다. 이 경우, 저는 Remix Js를 사용하고 있습니다. 만약 원하시면 Next Js나 React Js를 사용해도 됩니다.

프론트엔드에 Socket.IO 클라이언트를 설치해주세요.

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

```js
npm install socket.io-client@4.7.2
```

그런 다음 다음 코드를 추가하십시오.

```js
import { useEffect, useState } from "react";
import io from "socket.io-client";

let Io;

const backendUrl = "http://localhost:4000";

export default function SamplePage() {
  const [email, setEmail] = useState("laskar@mail.com");
  const [showText, setShowText] = useState("");

  const handleClick = async () => {
    try {
      if (!email) return alert("이메일을 입력해주세요");
      const response = await fetch(`${backendUrl}/buy`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ email }),
      });
      const data: any = await response.json();
      setShowText(data?.message);
    } catch (error) {
      console.log(error);
    }
  };
  useEffect(() => {
    Io = io(backendUrl);
    Io.on(`${email}-send`, (data) => {
      setShowText(data);
    });
    return () => {
      Io = io(backendUrl);
      Io.off(`${email}-send`);
    };
  }, [email]);
  return (
    <div className="flex items-center justify-center w-screen h-screen">
      <div>
        <div className="mb-5">
          <input className="p-2" value={email} onChange={(e) => setEmail(e.target.value)} />
        </div>
        <div className="px-2 py-2 mb-3">
          <button onClick={() => handleClick()}>구매</button>
        </div>
        <p className="font-semibold">{showText}</p>
      </div>
    </div>
  );
}
```

그런 다음 이메일을 입력하고 '구매'를 클릭하십시오. 그러면 주문이 처리되었다는 통지 텍스트가 표시됩니다. 정확하게 수행한 경우, 5초 후에 브라우저를 새로 고치지 않아도 "주문이 승인되었습니다"로 텍스트가 변경됩니다.

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

![image](/assets/img/2024-08-19-CreateaFIFOReal-timeNotificationsSystemWithRedisBullAndSocketIoInNodeJSBackend_3.png)

그리고 Redis와 Bull을 사용하여 FIFO 시스템을 구현하는 간단한 예제였습니다. 이 기사가 도움이 되었으면 좋겠어요.

전체 Node.js 코드를 확인하려면 제 깃허브를 방문해주세요.

https://github.com/laskar-ksatria/nodejs-fifo


Nodejs 백엔드에서 Redis, Bull 및 Socket IO를 사용한 실시간 FIFO 알림 시스템 구현하기


## 새 도구에 관한 간단한 소개

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

이 글에서는 새로운 Node.js 버전에 도입된 주목할만한 변경 사항을 살펴보겠습니다:

- add node:sqlite module (Colin Ihrig) #53752
- add matchesGlob method (Aviv Keller) #52881
- add postMessageToThread (Paolo Insogna) #53682

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

시작해 봅시다!

# node:sqlite

```js
// index.js

const { DatabaseSync } = require("node:sqlite");
const database = new DatabaseSync(":memory:");

// 문자열을 통해 SQL 문을 실행합니다.
database.exec(`
  CREATE TABLE data(
    id INTEGER PRIMARY KEY,
    name TEXT
  );
`);

// 데이터베이스에 데이터를 삽입하는 준비된 문을 작성합니다.
const insert = database.prepare("INSERT INTO data (id, name) VALUES (?, ?)");

// 바인딩된 값으로 준비된 문을 실행합니다.
insert.run(1, "Bob");
insert.run(2, "John");

// 데이터베이스에서 데이터를 읽는 준비된 문을 작성합니다.
const query = database.prepare("SELECT * FROM data ORDER BY id");

// 준비된 문을 실행하고 결과 세트를 로그에 기록합니다.
console.log(query.all());

// [ { id: 1, name: 'Bob' }, { id: 2, name: 'John' } ]
```

위 예제는 node:sqlite 모듈의 기본 사용법을 보여줍니다. 인-메모리 데이터베이스를 열고 데이터를 작성한 다음 데이터를 다시 읽어오는 과정을 보여줍니다.

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

--experimental-sqlite 플래그를 사용할 때 이 내장 라이브러리를 사용할 수 있습니다.

```js
node --experimental-sqlite index.js
```

우리 개발자들은 Node.js 기본 모듈과 함께 서버를 완전히 기능적으로 만들기 위해 많은 외부 모듈을 사용합니다. Node.js가 이러한 중요한 도구를 직접 포함하려고 노력하는 것은 훌륭합니다. 예를 들어, 최근에 테스트 러너의 네이티브 지원이 추가되어 jest와 mocha에서 네이티브 라이브러리로 전환했습니다. 이제는 데이터베이스와 ORM의 차례입니다.

현재 이것은 실험적인 모듈이며, 안정화되고 더 많은 메소드를 갖추기까지 시간이 필요할 것입니다.

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

Node.js Core 팀의 노력을 함께 감사하면서, 언젠가는 대부분의 주요 모듈이 기본적으로 제공되어 외부 라이브러리를 거의 사용하지 않게 될 것입니다.

# matchesGlob

이것은 다른 실험적인 메소드로, 경로가 패턴과 일치하는지를 결정합니다.

```js
path.matchesGlob("/foo/bar", "/foo/*"); // true
path.matchesGlob("/foo/bar*", "foo/bird"); // false
```

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

# postMessageToThread

마지막으로, 다른 worker에 값을 보내는 방법입니다. 이 worker는 thread ID로 식별됩니다.

이전에는 Message Channels를 사용하여 worker 스레드와 통신할 수 있었지만 이제는 스레드 간 통신이 훨씬 간단해졌습니다.

다음은 스레드 ID를 가져오는 방법입니다:

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

```js
const { threadId } = require("node:worker_threads");
```

그리고 이것이 서로 통신하는 방법입니다:

```js
postMessageToThread(id, { message: "pong" });
```

메시지를 먼저 받기 위해서는 리스너를 설정해야 합니다:

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

```js
process.on("workerMessage", (value, source) => {
  console.log(`${source} -> ${threadId}:`, value);
});
```

송신자의 스레드 ID가 소스입니다. 따라서 메시지를 되돌리고 싶다면 다음과 같이 할 수 있습니다.

```js
process.on("workerMessage", (value, source) => {
  console.log(`${source} -> ${threadId}:`, value);
  postMessageToThread(source, { message: "pong" });
});
```

메인 스레드와 통신하려면 메인 스레드 ID가 0이므로 그냥 0을 사용하면 됩니다.

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

```js
postMessageToThread(0, { message: "ping" });
```

완벽한 예제가 여기 있어요.

저의 요약을 즐겨주시기를 바랍니다. 제가 정보를 신속하게 전달하고 가장 중요한 업데이트를 강조하기 위해 노력했습니다.

그리고 제 JavaScript 뉴스레터를 Telegram에서 팔로우해주세요: @javascript


Nodejs V.2.25에서 새로 추가된 기능 정리


Next.js는 파일 시스템 기반 라우터를 사용합니다. 이 라우터를 사용하면 중첩된 경로에서 특정 동작을 가진 UI를 생성할 수 있습니다:

- layout : 세그먼트와 해당 자식들을 위한 공유 UI
- page : 경로의 고유 UI 및 공개 경로 생성
- loading : 세그먼트와 해당 자식들을 위한 로딩 UI
- not-found : 세그먼트와 해당 자식들을 위한 찾을 수 없음 UI
- error : 세그먼트와 해당 자식들을 위한 오류 UI
- global-error : 전역 오류 UI
- route : 서버 측 API 엔드포인트
- template : 특수 재랜더링된 레이아웃 UI
- default : 병렬 라우트에 대한 대체 UI

참고: 특수 파일에는 .js, .jsx 또는 .tsx 파일 확장자를 사용할 수 있습니다.

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

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

이 글에서는 Next.js (App Router)의 페이지 파일 역할을 이해하는 데 깊이 파고들어 볼 것입니다.

페이지는 경로에 고유한 UI입니다. 페이지를 정의하는 방법은 page.js 파일에서 컴포넌트를 기본 내보내기하는 것입니다.
해설:
웹 앱에서 "페이지"를 방문하는 특정 주소(또는 "경로")를 방문할 때 보는 특정 화면 또는 뷰로 생각해보세요. 예를 들어, 사이트의 홈페이지, "회사 소개" 페이지 또는 "연락처" 페이지는 모두 다른 "페이지"입니다.

간단히 말하면, 이러한 페이지 중 하나를 만들고 싶다면 프로젝트에서 page.js(또는 TypeScript를 사용하는 경우 page.tsx)라는 파일을 만들면 됩니다. 이 파일 안에 페이지가 어떻게 보일지 설명하는 코드를 작성한 다음, 이 코드를 내보냅니다. 방문자가 해당 경로를 방문할 때 표시되는 것이 이 내보낸 코드입니다.

예를 들어, 인덱스 페이지를 만들려면 앱 디렉토리 안에 page.js 파일을 추가하십시오:

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

<img src="/assets/img/2024-08-19-Nextjs14AppRouterSimplifiedAGuidetopagetsx_1.png" />

<img src="/assets/img/2024-08-19-Nextjs14AppRouterSimplifiedAGuidetopagetsx_2.png" />

그리고 더 많은 페이지를 만들려면 새 폴더를 만들고 해당 폴더 안에 page.js 파일을 추가하세요. 예를 들어, /dashboard 경로에 대한 페이지를 만들고 싶다면 dashboard라는 새 폴더를 만들고 그 안에 page.js 파일을 추가하세요:

참고:

1. 페이지는 .js, .jsx 또는 .tsx 파일 확장자를 사용할 수 있습니다.
2. 페이지는 항상 루트 서브트리의 말단입니다.
3. 말단: 자식이 없는 서브트리의 노드로, URL 경로의 마지막 세그먼트와 같은 것입니다.

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

![이미지1](/assets/img/2024-08-19-Nextjs14AppRouterSimplifiedAGuidetopagetsx_3.png)

4. 루트 세그먼트를 공개로 만들려면 page.js 파일이 필요합니다.
5. 페이지는 기본적으로 서버 컴포넌트이지만, 파일 상단에 "use client" 지시문을 사용하여 클라이언트 컴포넌트로 설정할 수 있습니다. 이 때, import 문 위에 위치해야 합니다.

![이미지2](/assets/img/2024-08-19-Nextjs14AppRouterSimplifiedAGuidetopagetsx_4.png)

![이미지3](/assets/img/2024-08-19-Nextjs14AppRouterSimplifiedAGuidetopagetsx_5.png)

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

6. 페이지에서 데이터를 가져올 수 있습니다.


Nextjs 14 App Router page.tsx 

작성자: Mark Thompson, Kristiyan Kostadinov

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

Angular의 내장 템플릿 구문을 확장하여 개발자들에게 구성 요소 템플릿 내에서 변수를 더 잘 정의할 수 있는 방법을 제공할 예정입니다.

새로운 @let 구문을 사용하면 개발자들은 변수를 정의하고 템플릿 전체에서 해당 값 재사용이 가능합니다. 또한 이 새로운 구문은 커뮤니티에서 가장 많은 추천을 받은 문제 중 하나를 해결할 수 있습니다.

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

위의 내용을 번역해 드리겠습니다.

템플릿에서 @let을 사용하여 개발자 경험을 향상시킬 수 있는 방법을 알아보세요.

# 재사용 가능한 템플릿 변수 정의하는 새로운 방법

Angular의 템플릿 구문은 복잡한 JavaScript 표현식을 지원하지만 표현식의 결과를 저장하고 템플릿 전체에서 재사용할 수 있는 원활한 방법이 없었습니다. 개발자들은 지시문 및 기타 해결책을 사용하여이 목표를 달성하기 위해 비효율적인 해결책을 찾아야 했습니다.

새로운 구문을 살펴볼까요?

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

@let name = value; // 여기서 value는 유효한 Angular 표현식입니다

이제 템플릿 내에서 변수를 정의하고 Angular의 템플릿 구문 규칙과 규칙에 따라 사용할 수 있습니다. 예를 들어:

@let name = 'Frodo';

<h1>Dashboard for {name}</h1>
Hello, {name}

다음은 @let이 템플릿에서 사용되는 방법의 또 다른 예시입니다:

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

```js

<input #name>

@let greeting = 'Hello ' + name.value;


@let user = user$ | async;
```

새로운 @let 선언을 사용할 때 주의해야 할 점은 해당 선언이 현재 뷰 및 하위 뷰에 스코프가 지정되지만 부모 또는 형제 뷰에서 액세스할 수 없다는 것입니다.

```js
@let topLevel = value;

@if (condition) {
  @let nested = value;
}

<div *ngIf="condition">
  @let nestedNgIf = value;
</div>


{topLevel}


{nested}


{nestedNgIf}
```

@let 선언은 읽기 전용이며 재할당할 수 없습니다. 그 값은 각 변경 감지마다 다시 계산될 것이며(예: async 파이프가 변경될 때), 직접 작성하려고 시도하면 타입 체크 오류가 발생합니다.

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

```js
@let value = 10;


<button (click)="value = value + 1">값 변경</button>
```

# 구문 정의

@let 구문의 세부 사항을 탐색해 봅시다. 새로운 구문의 공식적인 정의는 다음과 같습니다:

- @let 키워드.
- 새 줄을 제외한 하나 이상의 공백.
- 유효한 JavaScript 이름과 공백이 없는 한 개 이상.
- = 기호와 공백이 없는 한 개 이상.
- Angular 표현식으로 이어지며, 여러 줄일 수 있습니다.
- ; 기호로 종료됩니다.

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

# @즐거운 시간 시작하기

우리는 이 새로운 기능을 출시함으로써 정말 기쁩니다. 여러분의 개발자 경험을 향상시킬 수 있기를 바라며, 새로운 @let 구문에 대한 여러분의 의견을 듣고 싶어합니다. 이 블로그 게시물에 댓글을 달아주시거나 온라인에서 angular.dev, x.com/angular, youtube.com/@angular에서 저희를 찾아주시면 감사하겠습니다.

Angular에서의 let이 어떻게 동작하는지 이해하기


![image](/assets/img/2024-08-19-TheSilentScreamsofYourWebConsoleATaleofOverlookedPerformanceKillers_0.png)

웹 개발의 잊혀진 영웅

화려한 웹 개발 세계에서 세련된 UI와 첨단 프레임워크가 주목을 받는 가운데, 조용하게 지켜보고 있는 잊혀진 영웅이 있습니다: 겸손한 브라우저 콘솔입니다.

종종 단순한 디버깅 도구로 밀려나지만, 이 디지털 일기는 당신의 웹 앱의 진정한 잠재력을 발휘하는 열쇠를 쥐고 있습니다. 그러나 주의해야 할 점은, 그것이 멸망의 전조가 될 수도 있다는 것입니다!

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

콘솔이 화를 내다면

이렇게 상상해보세요: 당신은 반짝이는 새로운 앱 또는 앱 기능을 프로덕션에 푸시했습니다. UI는 완벽하게 보이고, 애니메이션이 부드럽게 작동하며, 자신에게 잘 했다고 자랑스러워 합니다.

그러나 표면 아래에서는 폭풍이 몰고 옵니다. 당신의 콘솔은 카페인 중독 경매 진행자보다 빠르게 오류를 토해내며 비명을 지르고 있습니다.

```js
@Component({
  selector: "app-chart",
  template: `<div>{ complexData.userLocation.coordinates.latitude }</div>`,
})
export class ChartComponent {
  complexData: any;
  // 어라, 때로는 이것이 정의되지 않을 수도 있습니다!
}
```

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

이 순진해 보이는 코드 조각이 초당 수천 개의 오류를 일으켜 브라우저를 느려지게 만드는 범인이 될 수 있습니다.

나비 효과: 작은 오류가 쓰나미를 일으킬 때

나비 효과를 기억하나요? 웹 성능의 세계에서 단 하나의 잘못된 글자가 재난으로 이어질 수 있습니다.

예를 들면, Angular 17 이주 스크립트 같은 거시기한 ?. 연산자를 제거한 경우, 이러한 작은 변경으로 혼란이 터질 수 있습니다. Angular의 변경 감지가 실행될 때마다 (이는 정말 자주 일어납니다), 브라우저에게 불을 뿌리며 루빅의 큐브를 풀도록 요청하는 것과 같습니다.

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

리소스 뱀파이어: 콘솔 오류가 웹 페이지를 배터리처럼 소모하는 이유

콘솔 오류는 작은 뱀파이어처럼 작용합니다. 각각이 웹 페이지에서 약간의 에너지를 빨아들이죠. 몇 개씩 발생하면 괜찮지만, 초당 수천 개가 발생한다면? 그건 정말 대규모 뱀파이어 아포칼립스!

이제 브라우저는 아름다운 UI를 렌더링하는 대신 오류를 기록하는 데 더 많은 리소스를 사용합니다. 모든 단계를 실시간으로 트윗하면서 마라톤을 달리는 것과 비슷합니다. 지칠 뿐이고 생산성이 떨어집니다.

표면 이상: 왜 백엔드 개발자도 신경 써야 할까요?

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

"하지만 나는 백엔드 개발자야," 하는 말이야. "나는 멋진 콘솔에 신경 쓰지 않아!" 음, 서버 쪽 동료여야 다시 한 번 생각해보세요. 그 콘솔 오류는 귀하의 API 응답과 실제 문제를 가리키고 있을 수도 있어요.

아마도 깨진 데이터를 보내거나, 혹은 오류 처리가 초콜릿 주전자만큼 효과적일 수도 있어요. 어쨌든 시끄러운 콘솔은 종종 깊은 문제의 캐너리 새라고 할 수 있어요.

콘솔 속삭임의 기술

그래서, 이 야수를 어떻게 다스릴까요? 모두 콘솔의 속삭임자가 되는 것이 중요해요. 안전한 탐색 연산자를 받아들이고, \*ngIf 가드를 스타일처럼 사용하며, 각종 오류 시나리오를 테스트하는 것은 천국의 모든 것을 위해 해주세요!"

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

```js
@Component({
  selector: "app-chart",
  template: `
    <div *ngIf="complexData?.userLocation?.coordinates">{ complexData.userLocation.coordinates.latitude }</div>
  `,
})
export class ChartComponent {
  complexData: any;
}
```

침묵하는 웹: 성능의 파라다이스

일요일 아침 도서관처럼 조용한 콘솔 세계를 상상해보세요. 당신의 웹 앱은 만족한 새끼 고양이처럼, 사용자들은 렉 없는 파라다이스에서 떠다니고, 서버는 효율적으로 운영됩니다. 이 유토피아는 당신이 콘솔의 속삭임을 듣는 법을 배우기만 한다면 손에 쥐을 수 있을 것입니다.

제안

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

콘솔을 웹 개발의 소홀히된 양자로 만들지 마세요. 디버깅 도구가 아닌 당신의 애플리케이션의 본질을 보여주는 창이에요.

콘솔을 잘 다루면, 부드럽고 원활한 성능과 행복한 사용자들이 기다리고 있을 거에요. 무시하면, 그럼... 수많은 에러 소리가 빈 공간으로 퍼질거에요!

결론

웹 개발의 큰 연극에서, 가끔은 가장 중요한 메시지를 전하는 가장 조용한 목소리들이 있어요. 그래서 콘솔에 귀를 기울여보세요 — 사용자들 (그리고 당신의 정신)이 감사할 거예요!

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

기사를 즐겼나요? 더 많은 웹 개발 채팅을 위해 LinkedIn에서 isinghprince와 연결해보세요!


웹 콘솔에서의 소리 없는 외침 간과된 성능 저하 요인들의 이야기


사전 준비 사항: Docker CLI 및 Kubernetes가 설치되어 있어야 해요.

로컬 Kubernetes에 배포해 봅시다. 먼저, 기본 Angular 및 .NET Web API 예제의 저장소를 복제하세요. 마스터 브랜치에 있는지 확인해주세요.

git clone https://github.com/uahmad565/Kubernetes-Angular-.NET-API.git

단계 1. .NET 8 API 배포

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

Visual Studio에서 BasicEcommerceWebApi.csproj 파일을 열어주세요. 그런 다음 Docker 지원을 추가하세요.

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

컨테이너 스캐폴딩 옵션:
대상 운영 체제: Linux
컨테이너 빌드 유형: Dockerfile

cmd에서 로컬로 Docker 이미지를 빌드하세요.

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

아래는 Docker Account 웹 사이트에서 얻은 "usman565" 사용자 이름으로 바꾸세요 (Google Cloud Kubernetes에 배포하기 위한 선택적 단계).

```js
docker build -t  usman565/ecommerceapi:v1 .
```

전제 조건: docker-cli가 설치되어 있으며 docker login을 사용하여 로그인되어 있어야 합니다.

```js
docker push
```

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

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapi
  labels:
    app: product-app
spec:
  replicas: 2
  selector:
    matchLabels:
      service: webapi
  template:
    metadata:
      labels:
        app: product-app
        service: webapi
    spec:
      containers:
        - name: webapicontainer
          image: usman565/ecommerceapi:v1 #이미지 변경
          # imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 80
              protocol: TCP
          env:
            - name: ASPNETCORE_URLS
              value: http://+:80 #컨테이너가 80번 포트에서 수신하도록 함
---
apiVersion: v1
kind: Service
metadata:
  name: webapiservice
  labels:
    app: product-app
    service: webapi
spec:
  ports:
    - port: 8080
      targetPort: 80 #2. 파드 컨테이너와 통신
      protocol: TCP
  selector:
    service: webapi #1. 중요한 부분
```

사용된 개념: backend-manifest.yml 파일은 포트를 지정하는 Pods + Containers의 간단한 Deployment인 Deployment입니다. Service의 역할은 무엇인가요? Service는 Deployment와 통신하는 데 사용됩니다.

- Angular Deployment에는 NodePort 타입의 서비스 "webappservice"가 있으며 이 서비스는 "webapp" Deployment Containers로 향하는 포트를 지정합니다. 이 서비스는 브라우저와 같은 외부 클라이언트에게 접근 가능합니다.
- .NET Deployment에는 ClusterIP 타입의 서비스 "webapiservice"가 있으며 이 서비스는 "webapi" Deployment Containers로 향하는 포트를 지정합니다. 이 서비스는 외부 IP가 없기 때문에 접근할 수 없지만 내부에서는 접근할 수 있습니다.

참고: NodePort 서비스는 프로덕션 환경에서 권장되지 않습니다. LoadBalancer 타입의 서비스는 여러 노드 간의 로드 밸런싱을 고려하므로 로컬 Kubernetes에서 사용하지 않습니다. 로드 밸런서는 클라우드별로 구현되는 것이 일반적입니다. 프로덕션 환경에서는 NodePort 대신 LoadBalancer 유형의 서비스를 사용합니다.

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

이미지를 backend-manifest.yml에서 다음과 같이 교체하세요.

```js
kubectl apply -f backend-manifest.yml
```

Angular 단계

"ng serve"가 작동하는 Angular 앱 루트에 "Dockerfile"을 추가하세요.

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

### STAGE 1: Build

FROM node:18.13-alpine AS build
WORKDIR /usr/src/app
COPY package.json package-lock.json ./
RUN npm install
COPY . .
RUN npm run build

### STAGE 2: Run

FROM nginx:1.17.1-alpine
COPY /nginx-custom.conf /etc/nginx/conf.d/default.conf
COPY --from=build /usr/src/app/dist/projectwith-ng-module/browser /usr/share/nginx/html
CMD ["nginx", "-g", "daemon off;"]
EXPOSE 80

옵션으로 .dockerignore을 추가할 수 있습니다.

**/node_modules/
**/.git
**/README.md
**/LICENSE
**/.vscode
**/npm-debug.log
**/coverage
**/.env
**/.editorconfig
**/.aws
\*\*/dist

nginx-custom.conf

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

```js
server {
    listen 80;
    location / {
        root /usr/share/nginx/html;
        index index.html index.htm;
        try_files $uri /index.html;
    }

    location /api/ {
        # The following statement will proxy traffic to the upstream named Backend
        proxy_pass http://webapiservice:8080;
    }

}
```

Reverse Proxy 역할이 매우 중요합니다. 브라우저가 요청을 nginx 서버로 전송하고 HTML, CSS 및 Javascript 파일을 제공받습니다. .NET에 대한 "/api/get/prodocuts"와 같은 요청을 보낼 때, /api가 일치하면 웹 API 서비스로 요청을 보냅니다. 이는 외부(브라우저 외부)에서 접근할 수 없습니다.

Angular 앱의 루트에 다음 deployment.yml 파일을 배치하세요.

```js
docker build -t usman565/ecommercefrontend:v1 . //usman565을 사용자 이름으로 바꿔주세요
docker push
```

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

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
  labels:
    app: product-app
spec:
  replicas: 2
  selector:
    matchLabels:
      service: webapp
  template:
    metadata:
      labels:
        app: product-app
        service: webapp
    spec:
      containers:
        - name: webappcontainer
          image: ecommercefrontend:v1
          ports:
            - containerPort: 80
              protocol: TCP
          env:
            - name: API_LINK
              value: http://webapiservice
---
apiVersion: v1
kind: Service
metadata:
  name: webappservice
  labels:
    app: product-app
    service: webapp
spec:
  type: NodePort
  ports:
    - port: 8080
      targetPort: 80
      protocol: TCP
  selector:
    service: webapp
```

다음 명령어를 사용하여 배포하실 수 있어요:

```bash
kubectl apply -f deployment.yml
```

웹앱 서비스에 할당된 포트를 확인하려면 다음 명령어를 사용해보세요:

```bash
kubectl get services
```

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

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

웹 API 서비스에 할당된 로컬호스트:포트로 브라우저 URL에 접속해보세요. 관련 질문이 있으면 언제든지 남겨주세요!

다음 구글 클라우드 쿠버네티스 엔진 GKE에 Kubernetes 배포 방법을 따르세요 - Uahmad - Medium

도움이 되는 기사들:

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

프론트엔드와 백엔드를 서비스를 이용하여 연결해보세요 | 쿠버네티스

쿠버네티스를 활용한 완전한 .NET Core API 및 앵귤러 애플리케이션 빌드하기 | Jaydeep Patil 저 | Plain English에서 JavaScript


Posts