개발환경 설정

https://start.spring.io/

dependencies에 spring web, spring data jpa, h2 database, lombok을 넣어주고 generate 한다.

압축파일은 java workspace에 압축 풀어준다.

File - Import - Gradle - Existing Gradle Project - Next - Project Root Directory 설정 - Override workspace setting 체크, Gradle wrapper 선택 - Finish

프로젝트 우클릭 후 Run as - Spring Boot App

Preferences - Server - Runtime Environments에서 Tomcat 10을 Add 프로젝트 우클릭 후 Properties - Projcet Facets - Dynamic Web Module 체크

프로젝트 우클릭 후 Run as - Run on server

웹브라우저에서 http://localhost:8080 에 접속한다.

• 🎈 Gradle: 빌드 자동화 툴. 컴파일, 라이브러리 다운로드, 패키징, 테스팅 등을 자동화 할 수 있다. 그루비라는 언어로 작성돼 있다.

🚨 The import org.springframework cannot be resolved

gradle에 sourceCompatibility = '17'와 implementation 'org.springframework.boot:spring-boot-starter'이 있는지 확인한다. 나의 경우에는 없어서 에러가 떴다.

🚨 프로젝트 실행이 안 돼요

자세히 보니 구조가 이상하다 이클립스 마켓플레이스에서 STS4를 설치하자 그리고 프로젝트를 다시 생성해 보자

필요 라이브러리 추가

스프링 부트 프로젝트를 하다 보면 라이브러리를 추가하는 상황이 온다. 메이븐 리포지터리를 이용해 라이브러리를 추가하면 된다.

https://mvnrepository.com

MVN Repository에서 Guava를 검색 후 Usages가 많은 것을 선택하자. 30.1.1-jre를 선택할 것이다. 구글 guava 라이브러리를 이용하면 자바 Collection을 간편하게 활용할 수 있다.

이클립스에 lombok 라이브러리도 추가하면 좋다. 롬복은 getter, setter, builder, constructor를 자동으로 작성해 준다. 코드의 양을 줄이고 개발 시간을 단축할 수 있다. 롬복 jar 파일을 다운로드해서 롬복 jar 파일이 있는 해당 경로로 cmd 창을 열어준다. java -jar lombok.jar 아마 자동으로 이클립스를 찾아줄 텐데, 찾지 못한다면 수동으로 이클립스 설치 폴더를 선택한 뒤 install/update 한다. 이클립스 재시작 후 Help - About Eclipse IDE를 선택하면 롬복이 설치된 것을 확인할 수 있다.

어노테이션 프로세서 설정

프로젝트 우클릭 - Java Compiler - Annotation Processing - Apply and Close

롬복의 동작 여부를 확인하기 위해 TodoModel.java를 생성한다.

import lombok.Builder;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;

@Builder
@RequiredArgsConstructor
public class TodoModel {
    @NonNull
    private String id;
}

Hello World 출력하기

1. TestController.java 생성

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class TestController {

    @GetMapping
    public String testController() {
        return "Hello World!";
    }
}

2. 프로젝트 실행

3. 웹 브라우저에서 localhost:8080/test를 입력하여 확인하기

Postman으로 Hello World 확인하기

포스트맨은 백엔드 개발을 할 때 request와 response를 확인할 수 있는 프로그램이다.

https://www.postman.com/downloads/

포스트맨을 통해 GET request를 실행한다.

@PathVariable 사용하기

    @GetMapping("/{id}")
    public String testControllerWithPathVariables(@PathVariable(required = false) int id) {
        return "Hello World! ID " + id;
    }

🚨 java.lang.IllegalArgumentException

Name for argument of type [int] not specified, and parameter name information not available via reflection. Ensure that the compiler uses the '-parameters' flag.

참고 - 스프링 부트 3.2 매개변수 이름 인식 문제 참고 - 인프런 @PathVariable 변수명 같을때 생략시 오류

PathVariable에 변수명을 명시해 주는 것이 권장하는 방법이다.

    @GetMapping("/{id}")
    public String testControllerWithPathVariables(@PathVariable("id") int id) {
        return "Hello World! ID " + id;
    }

@RequestParam

@RequestParam을 이용하여 매개변수를 전달 받을 수 있다. 이때 request 요청 URI는 localhost:8080/test/Param?id=123 형태다.

    @GetMapping("/Param")
    public String testControllerRequestParam(@RequestParam("id") int id) {
        return "Hello World! ID param " + id;
    }

@RequestBody

클라이언트 요청을 JSON 형식으로 받아 스트링을 반환하도록 해본다

1. TestRequestBodyDTO.java

   package com.example.todo.dto;
   

import lombok.Data;

@Data public class TestRequestBodyDTO { private int id; private String message; }

2. TestController.java
```java
    @GetMapping("/testRequestBody")
    public String testControllerRequstBody(@RequestBody TestRequestBodyDTO testRequestBodyDTO) {
        return "Hello World! ID: " + testRequestBodyDTO.getId() + " / Message: " + testRequestBodyDTO.getMessage();
    }

@ResponseBody

@RestController 내부는 @Controller, @ResponseBody 어노테이션으로 구성된다. @ResponseBody는 응답 객체를 만들어 클라이언트에게 반환한다.

1. ResponseDTO.java

   package com.example.todo.dto;
   

import java.util.List;

import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor;

@Builder @NoArgsConstructor @AllArgsConstructor @Data public class ResponseDTO { private String error; private List data; }

2. TestController.java
```java
    @GetMapping("/testResponseBody")
    public ResponseDTO<String> testControllerResponseBody() {
        List<String> list = new ArrayList<>();
        list.add("Hello world! I'm ResponseDTO");
        list.add("See you!");
        ResponseDTO<String> response = ResponseDTO.<String>builder().data(list).build();
        return response;
    }

ResponseEntity로 HTTP Status 조작

    @GetMapping("/testResponseEntityOk")
    public ResponseEntity<?> testControllerResponseEntityOk() {
        List<String> list = new ArrayList<>();
        list.add("Hello world! I'm ResponseEntity. And you get 200!");
        list.add("See you");
        ResponseDTO<String> response = ResponseDTO.<String>builder().data(list).build();
        return ResponseEntity.ok().body(response);
    }

    @GetMapping("/testResponseEntityBad")
    public ResponseEntity<?> testControllerResponseEntityBad() {
        List<String> list = new ArrayList<>();
        list.add("Hello world! I'm ResponseEntity. And you get 400!");
        list.add("See you");
        ResponseDTO<String> response = ResponseDTO.<String>builder().data(list).build();
        return ResponseEntity.badRequest().body(response);
    }

@Service

레이어드 아키텍처

1. 프리젠테이션 레이어(Controller) - dto
2. 비즈니스 레이어(Service) - model
3. 퍼시스턴스 레이어(Persistence) - entity
4. 데이터베이스 레이어(DB)

@Service는 스테레오 타입 컴포넌트다.

1. TodoService.java

   import org.springframework.stereotype.Service;
   

@Service public class TodoService { public String testService() { return "Test Service"; } }

2. TestController.java
```java
    @Autowired
    private TodoService todoService;

    @GetMapping("/service")
    public ResponseEntity<?> testService() {
        String str = todoService.testService();
        List<String> list = new ArrayList<>();
        list.add(str);
        ResponseDTO<String> response = ResponseDTO.<String>builder().data(list).build();
        return ResponseEntity.ok().body(response);
    }

@Repository 사용하기

스프링 부트로 웹 개발 시 패키지에 포함되는 일반적인 클래스는 크게 3가지다.

1. @Controller(@RestController)
   • 프리젠테이션. Request, Response 기능 담당. JSON 형식 값을 전달하기 위해 @RestController를 사용한다.
2. @Service
   • 비즈니스 로직 구현 클래스. request에서 넘어온 파라미터 또는 기능 요청에 대해 실제적인 기능을 수행하는 역할을 함. DB 테이블에 값을 저장하거나 값을 검색해 오는 역할 담당
3. @Repository
   • 퍼시스턴스 레이어에 속하는 interface 클래스. JPARepository에서 상속받음. 관계형 DB의 CRUD를 상속받아 처리하므로 선언만 하고 내부 로직을 구현할 필요는 없음. 스프링 데이터 JPA가 AOP 인터페이스를 통해 메소드를 가로채 실행하기 때문

1. TodoEntity.java

   package com.example.todo.model;
   

import org.hibernate.annotations.GenericGenerator;

import jakarta.persistence.Entity; import jakarta.persistence.GeneratedValue; import jakarta.persistence.Id; import jakarta.persistence.Table; import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor;

@Builder @NoArgsConstructor @AllArgsConstructor @Data @Entity @Table(name = "Todo") public class TodoEntity { @Id @GeneratedValue(generator = "system-uuid") // 자동으로 id 생성 @GenericGenerator(name = "system-uuid", strategy = "uuid") private String id;

private String usrId;
private String title;
private boolean done;

}

2. TodoRepository.java
```java
package com.example.todo.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.todo.model.TodoEntity;

@Repository
public interface TodoRepository extends JpaRepository<TodoEntity, String> {

}

3. TodoService.java

   @Service
   public class TodoService {
    @Autowired
    private TodoRepository repository;
   
    public String testService() {
        // Todo entity 생성
        TodoEntity entity = TodoEntity.builder().title("my first todo item").build();
        // Todo entity 저장
        repository.save(entity);
        // Todo entity 검색
        TodoEntity savedEntity = repository.findById(entity.getId()).get();
        return savedEntity.getTitle();
    }
   }

4. TestController.java

    @GetMapping("/repository")
    public ResponseEntity<?> testRepository() {
        String str = todoService.testService();
        List<String> list = new ArrayList<>();
        list.add(str);
        ResponseDTO<String> response = ResponseDTO.<String>builder().data(list).build();
        return ResponseEntity.ok().body(response);
    }

@Repository에서 쿼리 추가하기

1. TodoRepository.java

   @Repository
   public interface TodoRepository extends JpaRepository<TodoEntity, String> {
    List<TodoEntity> findByUsrId(String usrId);
   }

2. TodoService.java

    public String testService() {
        // Todo entity 생성
        TodoEntity entity = TodoEntity.builder().usrId("usrId01").title("my first todo item").build();
        // Todo entity 저장
        repository.save(entity);
        // Todo entity 검색
        TodoEntity savedEntity = repository.findByUsrId(entity.getUsrId()).get(0);
        return savedEntity.getUsrId();
    }

@NamedQuery, @Query 사용하기

JPA에서 제공하는 기본 쿼리 외에 SQL을 사용하여 사용자가 쿼리를 지정할 수 있다. @NamedQuery를 사용한 쿼리는 Entity 클래스에서 정의하여 사용한다.

1. TodoEntity.java

   @Builder
   @NoArgsConstructor
   @AllArgsConstructor
   @Data
   @Entity
   @Table(name = "Todo")
   @NamedQuery(name = "TodoRepository.searchByUsrId", query = "select t from TodoEntity t where t.usrId = ?1")
   public class TodoEntity {
    @Id
    @GeneratedValue(generator = "system-uuid")    // 자동으로 id 생성
    @GenericGenerator(name = "system-uuid", strategy = "uuid")
    private String id;
   
    private String usrId;
    private String title;
    private boolean done;
   }

2. TodoRepository.java

   @Repository
   public interface TodoRepository extends JpaRepository<TodoEntity, String> {
    List<TodoEntity> searchByUsrId(String usrId);
   }

3. TodoService.java

    public String testService() {
        // Todo entity 생성
        TodoEntity entity = TodoEntity.builder().usrId("usrId01").title("my first todo item").build();
        // Todo entity 저장
        repository.save(entity);
        // Todo entity 검색
        TodoEntity savedEntity = repository.searchByUsrId(entity.getUsrId()).get(0);
        return savedEntity.getUsrId();
    }

다음은 @Query를 사용하여 SQL을 질의하는 방법이다. TodoRepository.java만 수정하면 되므로 비교적 간단하다. @NamedQuery 구문은 삭제한다.

1. TodoEntity.java

   @Builder
   @NoArgsConstructor
   @AllArgsConstructor
   @Data
   @Entity
   @Table(name = "Todo")
   public class TodoEntity {
    @Id
    @GeneratedValue(generator = "system-uuid")    // 자동으로 id 생성
    @GenericGenerator(name = "system-uuid", strategy = "uuid")
    private String id;
   
    private String usrId;
    private String title;
    private boolean done;
   }

2. TodoRepository.java

   @Repository
   public interface TodoRepository extends JpaRepository<TodoEntity, String> {
    @Query("select t from TodoEntity t where t.usrId = ?1")
    List<TodoEntity> searchByUsrId(String usrId);
   }

Todo 앱 만들기

HTTP POST를 이용한 Create REST API 개발

1. TodoRepository.java

   @Repository
   public interface TodoRepository extends JpaRepository<TodoEntity, String> {
   

}

2. TodoEntity.java
```java
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Data
@Entity
@Table(name = "Todo")
public class TodoEntity {
    @Id
    @GeneratedValue(generator = "system-uuid") // 자동으로 id 생성
    @GenericGenerator(name = "system-uuid", strategy = "uuid")
    private String id;

    private String usrId;
    private String title;
    private boolean done;
}

3. TodoDTO.java

   @Builder
   @NoArgsConstructor
   @AllArgsConstructor
   @Data
   public class TodoDTO {
    private String id;
    private String title;
    private boolean done;
   
    // entity to dto
    public TodoDTO(final TodoEntity entity) {
        this.id = entity.getId();
        this.title = entity.getTitle();
        this.done = entity.isDone();
    }
   
    // dto to entity
    public static TodoEntity toEntity(final TodoDTO dto) {
        return TodoEntity.builder()
                .id(dto.getId())
                .title(dto.getTitle())
                .done(dto.isDone())
                .build();
    }
   }

4. ResponseDTO.java

   @Builder
   @NoArgsConstructor
   @AllArgsConstructor
   @Data
   public class ResponseDTO<T> {
    private String error;
    private List<T> data;
   }

5. TodoService.java

   @Slf4j
   @Service
   public class TodoService {
   
    @Autowired
    private TodoRepository repository;
   
    public Optional<TodoEntity> create(final TodoEntity entity) {
        // Validation
        validate(entity);
        repository.save(entity);
        return repository.findById(entity.getId());
    }
   
    public void validate(final TodoEntity entity) {
        if (entity == null) {
            log.warn("Entity cannot be null");
            throw new RuntimeException("Entity cannot be null");
        }
   
        if (entity.getUsrId() == null) {
            log.warn("Unknown user");
            throw new RuntimeException("Unknown user");
        }
    }
   }

6. TodoController.java

   @Slf4j
   @RestController
   @RequestMapping("/todo")
   public class TodoController {
    @Autowired
    private TodoService service;
   
    @PostMapping
    public ResponseEntity<?> createTodo(@RequestBody TodoDTO dto) {
        try {
            log.info("Log: createTodo entrance");
            TodoEntity entity = TodoDTO.toEntity(dto);
   
            log.info("Log:dto -> entity ok");
            entity.setUsrId("temporary-usrId");
   
            Optional<TodoEntity> entities = service.create(entity);
            log.info("Log:service.create ok");
   
            List<TodoDTO> dtos = entities.stream().map(TodoDTO::new).collect(Collectors.toList());
            log.info("Log:entities -> dtos ok");
   
            ResponseDTO<TodoDTO> response = ResponseDTO.<TodoDTO>builder().data(dtos).build();
   
            return ResponseEntity.ok().body(response);
        } catch (Exception e) {
            String error = e.getMessage();
            ResponseDTO<TodoDTO> response = ResponseDTO.<TodoDTO>builder().error(error).build();
   
            return ResponseEntity.badRequest().body(response);
        }
    }
   }

HTTP GET을 이용한 Retrieve REST API 개발

1. TodoRepository.java

   @Repository
   public interface TodoRepository extends JpaRepository<TodoEntity, String> {
    @Query("select t from TodoEntity t where t.usrId = ?1")
    List<TodoEntity> findByUsrId(String usrId);
   }

2. TodoService.java

    public List<TodoEntity> retrieve(final String usrId) {
        return repository.findByUsrId(usrId);
    }

3. TodoController.java

    @GetMapping
    public ResponseEntity<?> retrieveTodoList() {
        String temporaryUsrId = "temporary-usrId";
        List<TodoEntity> entities = service.retrieve(temporaryUsrId);
        List<TodoDTO> dtos = entities.stream().map(TodoDTO::new).collect(Collectors.toList());
        ResponseDTO<TodoDTO> response = ResponseDTO.<TodoDTO>builder().data(dtos).build();
        return ResponseEntity.ok().body(response);
    }

HTTP PUT을 이용한 Update REST API 개발

• application.properties에 h2 database configuration 설정하고 h2 console을 설정한다.

application.properties

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
spring.h2.console.settings.trace=false
spring.h2.console.settings.web-allow-others=false

1. TodoService

    public Optional<TodoEntity> update(final TodoEntity entity){
        validate(entity);
        if (repository.existsById(entity.getId())) {
            repository.save(entity);
        } else {
            throw new RuntimeException("Unknown id");
        }
   
        return repository.findById(entity.getId());
    }
   
    public Optional<TodoEntity> updateTodo(final TodoEntity entity) {
        validate(entity);
        final Optional<TodoEntity> original = repository.findById(entity.getId());
   
        original.ifPresent(todo -> {
            todo.setTitle(entity.getTitle());
            todo.setDone(entity.isDone());
            repository.save(todo);
        });
   
        return repository.findById(entity.getId());
    }

2. TodoController

    @GetMapping("/update")
    public ResponseEntity<?> update(@RequestBody TodoDTO dto) {
        try {
            TodoEntity entity = TodoDTO.toEntity(dto);
            entity.setUsrId("temporary-usrId");
            Optional<TodoEntity> entities = service.update(entity);
            List<TodoDTO> dtos = entities.stream().map(TodoDTO::new).collect(Collectors.toList());
            ResponseDTO<TodoDTO> response = ResponseDTO.<TodoDTO>builder().data(dtos).build();
            return ResponseEntity.ok().body(response);
        } catch (Exception e) {
            String error = e.getMessage();
            ResponseDTO<TodoDTO> response = ResponseDTO.<TodoDTO>builder().error(error).build();
   
            return ResponseEntity.badRequest().body(response);
        }
    }
   
    @PutMapping
    public ResponseEntity<?> updateTodo(@RequestBody TodoDTO dto) {
        try {
            TodoEntity entity = TodoDTO.toEntity(dto);
            entity.setUsrId("temporary-usrId");
            Optional<TodoEntity> entities = service.updateTodo(entity);
            List<TodoDTO> dtos = entities.stream().map(TodoDTO::new).collect(Collectors.toList());
            ResponseDTO<TodoDTO> response = ResponseDTO.<TodoDTO>builder().data(dtos).build();
            return ResponseEntity.ok().body(response);
        } catch (Exception e) {
            String error = e.getMessage();
            ResponseDTO<TodoDTO> response = ResponseDTO.<TodoDTO>builder().error(error).build();
   
            return ResponseEntity.badRequest().body(response);
        }
    }

http://localhost:8080/h2-console에 application.properties에 작성한 접속 정보로 접속 시 DB를 확인할 수 있다.

Minikube 실행

• Podman 드라이버를 사용하여 Minikube를 실행

$ minikube start --driver=podman --container-runtime=cri-o

Minikube 배포 확인

$ kubectl get node
$ kubectl get pods -n kube-system

CoreDNS 스크립트 적용

• 쿠버네티스 내부 통신을 위한 스크립트 파일 적용

$ cd ~/edu-msa-file
$ chmod +x coredns-apply.sh
$ ./coredns-apply.sh

CoreDNS 적용 확인

• CoreDNS YAML 파일에 'localdomain' 문구가 적용되었는지 확인

$ kubectl get cm coredns -n kube-system -o yaml

Minikube IP 주소 조회

• 서비스 포트의 외부 통신을 위한 Minikube IP 주소를 확인

$ minikube ip

Redis 배포 준비

• redis-msa-ui.yaml 파일 수정

$ vim ~/edu-msa-file/Kubernetes/redis-msa-ui.yaml
${REDIS_MSA_UI}를 "30801"로 수정

Redis 배포

• redis-msa-ui.yaml 배포

$ cd ~/edu-msa-file/Kubernetes/
$ kubectl apply -f redis-msa-ui.yaml

MySql 배포 준비

$ vim ~/edu-msa-file/Kubernetes/mysql-msa-board.yaml
${MYSQL_MSA_BOARD}을 "30501"로 수정

$ vim ~/edu-msa-file/Kubernetes/mysql-msa-comment.yaml
${MYSQL_MSA_COMMENT}을 "30601"로 수정

$ vim ~/edu-msa-file/Kubernetes/mysql-msa-user.yaml
${MYSQL_MSA_USER}을 "30701"로 수정

MySql 배포 및 DB 구축 (board, comment, user)

$ cd ~/edu-msa-file/Kubernetes/
$ kubectl apply -f mysql-msa-board.yaml -f mysql-msa-comment.yaml -f mysql-msa-user.yaml

MySql 배포 확인

$ kubectl get pods

Board DB 접속, DB 구축

# kubectl exec -it ${POD_NAME} -- /bin/bash  
#조회한 파드의 이름을 아래와 같이 입력하시면 됩니다.
예시) $ kubectl exec -it mysql-msa-board-85bb55fb4f-gpj9f -- /bin/bash

# mysql -u root -p
Enter password: password

mysql> CREATE DATABASE msa_board default CHARACTER SET UTF8;
mysql> USE msa_board;
mysql> CREATE TABLE `TB_BOARD` (
  `board_seq` int(11) NOT NULL AUTO_INCREMENT,
  `board_title` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `board_text` mediumtext COLLATE utf8_unicode_ci,
  `write_user_id` varchar(20) COLLATE utf8_unicode_ci NOT NULL,
  `write_user_name` varchar(20) COLLATE utf8_unicode_ci NOT NULL,
  `use_yn` varchar(1) COLLATE utf8_unicode_ci DEFAULT 'Y',
  `create_dt` datetime NOT NULL,
  `update_dt` datetime NOT NULL,
  PRIMARY KEY (`board_seq`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

> exit
# exit

Comment DB 접속, DB 구축

# kubectl exec -it ${POD_NAME} -- /bin/bash  
#조회한 파드의 이름을 아래와 같이 입력하시면 됩니다.
예시) $ kubectl exec -it mysql-msa-comment-694d68d4ff-562wk -- /bin/bash

# mysql -u root -p
Enter password: password

mysql> CREATE DATABASE msa_comment default CHARACTER SET UTF8;
mysql> USE msa_comment;
mysql> CREATE TABLE `TB_COMMENT` (
  `comment_seq` int(11) NOT NULL AUTO_INCREMENT,
  `board_seq` int(11) NOT NULL,
  `comment` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
  `write_user_id` varchar(20) COLLATE utf8_unicode_ci NOT NULL,
  `write_user_name` varchar(20) COLLATE utf8_unicode_ci NOT NULL,
  `use_yn` varchar(1) COLLATE utf8_unicode_ci DEFAULT 'Y',
  `create_dt` datetime NOT NULL,
  `update_dt` datetime NOT NULL,
  PRIMARY KEY (`comment_seq`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

> exit
# exit

User DB 접속, DB 구축

# kubectl exec -it ${POD_NAME} -- /bin/bash  
#조회한 파드의 이름을 아래와 같이 입력하시면 됩니다.
예시) $ kubectl exec -it mysql-msa-user-6c5499bbb5-29skb -- /bin/bash

# mysql -u root -p
Enter password: password

mysql> CREATE DATABASE msa_user default CHARACTER SET UTF8;
mysql> USE msa_user;
mysql> CREATE TABLE `TB_USER` (
  `user_seq` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` varchar(20) COLLATE utf8_unicode_ci NOT NULL,
  `user_passwd` varchar(256) COLLATE utf8_unicode_ci NOT NULL,
  `user_name` varchar(20) COLLATE utf8_unicode_ci NOT NULL,
  `use_yn` varchar(1) COLLATE utf8_unicode_ci DEFAULT 'Y',
  `create_dt` datetime NOT NULL,
  `update_dt` datetime NOT NULL,
  PRIMARY KEY (`user_seq`),
  UNIQUE KEY `id_key` (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

> exit
# exit

🚨 (참고) 실습 시 유의사항 VM 재시작 시 CoreDNS 스크립트 적용, Mysql DB 재구축 필요

1. Minikube 실행
2. Pod, Service 정상 동작 확인, CoreDNS 스크립트 적용
3. 파드 별 Mysql DB 재구축 필요
4. 실습포털 접속하여 각 기능 정상 동작 확인

war 파일 생성

JDK 8 다운로드

• jdk-8u***-window-x64.exe Download URL

eGovFrameDev 다운로드

• eGovFrameDev-3.9.0-64bit.exe Download URL
• 개발자용 개발환경 32&64bit(Implementation Tool) Version 3.9.0

API 소스 다운로드

• Download URL
• 'edu-msa'로 검색하여 edu-msa-ui, edu-msa-zuul, edu-msa-user, edu-msa-comment, edu-msa-board API 소스 파일 다운로드

프로젝트 추가 후 설정 파일 수정

• edu-msa-[board, comment, user] api.properties
  • ${NAMESPACE}: "default" 입력
  • ${KUBERNETES_URL}: Minikube IP 주소 입력
  • ${MYSQL_MSA_BOARD}: 30501
  • ${MYSQL_MSA_COMMENT}: 30601
  • ${MYSQL_MSA_USER}: 30701
• edu-msa-ui api.properties
  • ${NAMESPACE}: "default"
  • ${KUBERNETES_URL}: Minikube IP 주소 입력
  • ${REDIS_MSA_UI}: 30801

각 프로젝트(board, comment, ui, user, zuul) Maven build를 통해 war 파일 생성

각 war 파일을 서버의 /edu-msa-file/Docker/ 폴더 안의 edu-msa-* 각 폴더로 이동

이미지 생성 및 배포

war 파일과 server.xml이 같은 폴더 안에 구성되어 있는지 확인 (board, comment, ui, user)

war 파일과 application.yml이 같은 폴더 안에 구성되어 있는지 확인 (zuul)

Docker hub

• 도커에서 운영하는 도커 이미지 저장소 서비스

Docker hub URL

계정 생성 후, Repositories 클릭하여 Repository Name 입력 후 이미지 저장소 생성 (board, comment, ui, user, zuul)

이미지 저장소 로그인

$ podman login docker.io
Username: 아이디 입력
Password: 패스워드 입력

이미지 빌드, 태그, 업로드 (board, comment, ui, user, zuul)

$ cd ~/edu-msa-file/Docker/edu-msa-board/ 
$ podman build --tag edu-msa-board:latest .
$ podman tag edu-msa-board ${도커허브 ID}/edu-msa-board
$ podman push ${도커허브 ID}/edu-msa-board

$ cd ~/edu-msa-file/Docker/edu-msa-comment/ 
$ podman build --tag edu-msa-comment:latest .
$ podman tag edu-msa-comment ${도커허브 ID}/edu-msa-comment
$ podman push ${도커허브 ID}/edu-msa-comment

$ cd ~/edu-msa-file/Docker/edu-msa-ui/ 
$ podman build --tag edu-msa-ui:latest .
$ podman tag edu-msa-ui ${도커허브 ID}/edu-msa-ui
$ podman push ${도커허브 ID}/edu-msa-ui

$ cd ~/edu-msa-file/Docker/edu-msa-user/ 
$ podman build --tag edu-msa-user:latest .
$ podman tag edu-msa-user ${도커허브 ID}/edu-msa-user
$ podman push ${도커허브 ID}/edu-msa-user

$ cd ~/edu-msa-file/Docker/edu-msa-zuul/ 
$ podman build --tag edu-msa-zuul:latest .
$ podman tag edu-msa-zuul ${도커허브 ID}/edu-msa-zuul
$ podman push ${도커허브 ID}/edu-msa-zuul

MSA Application 배포

edu-msa-[board, comment, ui, user, zuul] yaml 파일 수정

$ vim ~/edu-msa-file/Kubernetes/edu-msa-board.yaml
${DOCKER_HUB_ID}을 "도커허브계정"로 입력
${EDU_MSA_BOARD}을 "30201"로 수정

$ vim ~/edu-msa-file/Kubernetes/edu-msa-comment.yaml
${DOCKER_HUB_ID}을 "도커허브계정"로 입력
${EDU_MSA_COMMENT}을 "30301"로 수정

$ vim ~/edu-msa-file/Kubernetes/edu-msa-ui.yaml
${DOCKER_HUB_ID}을 "도커허브계정"로 입력
${EDU_MSA_UI}을 "30001"로 수정

$ vim ~/edu-msa-file/Kubernetes/edu-msa-user.yaml
${DOCKER_HUB_ID}을 "도커허브계정"로 입력
${EDU_MSA_USER}을 "30401"로 수정

$ vim ~/edu-msa-file/Kubernetes/edu-msa-zuul.yaml
${DOCKER_HUB_ID}을 "도커허브계정"로 입력
${NAMESPACE}을 "default"로 입력 (총 3줄)
${EDU_MSA_ZULL}을 "30101"로 수정

edu-msa-[board, comment, ui, user, zuul] yaml 파일 API 배포

$ cd ~/edu-msa-file/Kubernetes/
$ kubectl apply -f edu-msa-board.yaml -f edu-msa-comment.yaml -f edu-msa-ui.yaml -f edu-msa-user.yaml -f edu-msa-zuul.yaml

Pod 및 Service 배포 확인

$ kubectl get pods
$ kubectl get service

MSA Application 포털 접속

• VMware 화면 속 웹 브라우저에서 Minikube IP 주소와 edu-msa-ui의 노드 포트 번호를 통해 MSA 앱 접속을 실행하여 회원가입, 게시판, 댓글 기능이 정상 작동하는지 확인
• ex. 192.168.49.2:30001/user/login

Minikube

• 로컬 환경에서 쿠버네티스 클러스터 환경을 단일 워커 노드로 구현하여 사용할 수 있는 도구

Minikube 설치

$ cd ~
$ wget https://github.com/kubernetes/minikube/releases/download/v1.32.0/minikube-linux-amd64
$ sudo cp minikube-linux-amd64 /usr/local/bin/minikube
$ sudo install minikube-linux-amd64 /usr/local/bin/minikube
$ minikube version

kubectl 설치

• ✅ Minikube 클러스터에 명령을 내리는 CLI

$ curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.29.2/bin/linux/amd64/kubectl
$ chmod +x ./kubectl
$ sudo mv ./kubectl /usr/local/bin/kubectl
$ kubectl version -o json  --client

Podman 설치

Podman

• 리눅스 시스템에서 컨테이너를 개발, 관리, 실행하기 위한 오픈소스 툴
• 데몬이 없는 포괄적인 아키텍처로 컨테이너를 더 안전하고 손쉽게 관리할 수 있고, 관련 툴과 기능을 통해 컨테이너 환경을 사용자 정의 방식으로 요구사항에 적합하게 설정할 수 있음

Podman 설치 및 MSA 애플리케이션 배포 파일 다운로드

• ✅ Podman 설치 및 MSA 애플리케이션 배포를 위한 배포 설정 파일을 다운로드한다.

$ cd ~
$ git clone https://github.com/K-PaaS/edu-msa-file.git

Podman 설치

• 컨테이너 및 컨테이너 이미지를 개발, 관리, 실행하기 위한 컨테이너 엔진 Podman을 설치
• /etc/containers/ 경로에 있는 registries.conf 파일과 policy.json 파일을 수정한다.

$ cd ~/edu-msa-file
$ chmod +x podman-install.sh
$ sudo ./podman-install.sh
$ sudo rm -rf ~/.local/share/containers/

$ cd /etc/containers/
$ sudo rm registries.conf
$ sudo vim registries.conf

아래 내용 붙여넣기

[registries.search]
registries=["docker.io"]

$ sudo rm policy.json
$ sudo vim policy.json

아래 내용 붙여넣기

{"default":[{"type":"insecureAcceptAnything"}]}

Podman 설정 적용

$ sudo podman system reset

• ✅ VMware Workstation pro(Personal Use) 설치 가능한 개인용 PC (Windows 환경 사용 권장)
  • CPU: 4개 이상
  • 메모리(RAM): 16GB 이상
  • 디스크: 30GB 이상 (Minikube 배포 최소 필요 공간)
  • VMware Workstation Pro Download URL
• ✅ OS: Ubuntu 20.04
  • Ubuntu 20.04 Image Download URL
• ✅ CPU: 4 core 이상
• ✅ 메모리: 12GB 이상 (16GB 이상 권장)
• ✅ 디스크: 30GB 이상의 여유 공간
• ✅ 기타: 인터넷 연결 가능한 환경, 외부 포트 개방 환경 (SFTP 기능 사용 시 필요)

가상머신 실행 후 Openssh 서버 설치 및 IP 주소 확인 sudo apt install -y openssh-server ip a

SSH 접속

MobaXterm

• Window 환경에서 SSH, FTP 등 다양한 원격접속을 할 수 있는 프로그램
• MobaXterm Home Edition Download URL

사전 패키지 업데이터 및 툴 설치

• sudo apt-get update
• sudo apt-get install -y curl vim git

1. K-PaaS 컨테이너 플랫폼과 유사한 Minikube 실습환경의 Architecture 및 배포 흐름을 이해할 수 있다.
2. 가상머신, Minikube, Podman을 활용하여 실습환경을 구성할 수 있다.
3. 구성한 실습환경에서 컨테이너 이미지 생성 및 컨테이너 배포를 통해 MSA Application을 구축할 수 있다.

실습 개요

📌 (실습 목표) 컨테이너 이미지 생성 및 컨테이너 배포를 통한 MSA 애플리케이션 구축

Architecture 구성 이해

배포 흐름도

1. 가상머신 설치 Ubuntu 20.04 다운로드
2. Minikube 설치 Kubectl 설치
3. Podman 설치
4. Redis, DB 환경 구축
5. war파일 생성 이미지 생성 및 배포
6. Minikube 클러스터 API yaml 배포

K-PaaS 가이드 문서 컨테이너 플랫폼 소스 컨트롤 가이드

소스 컨트롤

• 시스템 형상 요소의 기능적 특성이나 물리적 특성을 문서화하고 그러한 특성의 변경을 관리하며, 변경의 과정이나 실현 상황을 기록 및 보고하여 지정된 요건이 충족되었다는 사실을 검증하는 것, 또는 그 과정
• 형상 관리는 프로젝트를 개발하는 동안 생산성과 안정성을 높여 좋은 품질의 소프트웨어를 생산하고 유지보수도 용이하게 하는데 목적이 있음

소프트웨어 형상 관리(SCM, Software Configuration Management) 기능

• 언제라도 특정 시간대에 가장 안정적인 버전의 소프트웨어를 유지할 수 있도록 소프트웨어 제품이 변경되어가는 상태에 대한 가시성을 확보
• 적절한 변경 관리를 통하여 무절제한 변경을 사전에 예방하고 변경에 따른 부작용을 최소화

K-PaaS 가이드 문서 컨테이너 플랫폼 파이프라인 설치 가이드

Pipeline

• 생산 라인 등과 같이 여러 공정별로 생산 라인이 나열되어 있고 동시에 공정별 프로세서를 가능하게 하는 것
• 시스템의 효율을 높이기 위해 명령문을 수행하면서 몇 가지의 특수한 작업들을 병렬 처리하도록 설계된 하드웨어 기법

파이프라인 기능 및 역할

• 각 프로세스들을 저장한 파일 이름들 사이를 수직선으로 분리시키면 셀(cell)이 인식. 즉, 수직선 왼쪽 파일의 출력이 오른쪽 파일의 입력으로 연결됨
• 배포 파이프라인은 지속적 배포의 핵심 요소

K-PaaS 가이드 문서 컨테이너 플랫폼 포털 설치 가이드 문서

포털 배포 파일 다운로드

• 컨테이너플랫폼포털배포(Deployment) 파일을 다운로드하여 해당경로에 위치
• ✅ 이 단계는 반드시 Kubernetes Control Plane(Master Node) 노드에서 진행해야 함

1. 컨테이너 플랫폼포털배포(Deployment) 파일 다운로드

   # Deployment 파일 다운로드 경로 생성 
   $ mkdir -p ~/workspace/container-platform 
   $ cd ~/workspace/container-platform 
   # Deployment 파일 다운로드 및 파일 경로확인 
   $ wget --content-disposition https://nextcloud.k-paas.org/index.php/s/ZcFt4cpeXj8d4o4/download 
   $ ls ~/workspace/container-platform 
   cp-portal-deployment-v1.6.0.tar.gz 
   # Deployment 파일 압축 해제 
   $ tar -xvf cp-portal-deployment-v1.6.0.tar.gz

2. 배포(Deployment) 파일 디렉토리 구성

포털 변수 정의

• 컨테이너플랫폼포털배포 전변숫값정의가 필요하므로 배포에 필요한 정보를 확인하여 변수를 설정
• Keycloak 기본배포프로토콜은 HTTP이며 인증서를 통한 HTTPS를 설정하고자 하는 경우 아래가이드를 참조하여 먼저 처리한다.

1. 쉘파일 실행

   $ cd ~/workspace/container-platform/cp-portal-deployment/script 
   $ vi cp-portal-vars.sh

2. 컨테이너 플랫폼 포털 변수 정의

   $ cd ~/workspace/container-platform/cp-portal-deployment/script 
   $ vi cp-portal-vars.sh

포털 배포

• 컨테이너 플랫폼 포털 배포 스크립트 실행 및 정상 배포 확인

1. 쉘파일 실행

   $ chmod +x deploy-cp-portal.sh 
   $ ./deploy-cp-portal.sh

2. 리소스별로 정상 배포되었는지 확인

   $ kubectl get all -n harbor 
   $ kubectl get all –n mariadb 
   $ kubectl get all –n keycloak 
   $ kubectl get all –n cp-portal 
   $ kubectl get all –n vault 
   $ kubectl get all –n chartmuseum 
   $ kubectl get all –n chaos-mesh

• ✅ 리소스 Pod의 경우 Node에 바인딩 및 컨테이너생성 후 Running 상태로 전환되기까지 몇 초 소요됨
• 서비스접속 Host 조회 $ kubectl get ingress –A

포털 리소스 정상 배포 확인

• Harbor 리소스 조회 : $ kubectl get all -n harbor ✅ Harbor는 Kubespray를 통해 설치된 Kubernetes Cluster 환경에 포털이미지 및 Helm Chart를 관리
• MariaDB 리소스 조회 : $ kubectl get all -n mariadb ✅ MariaDB(RDBMS)는 메타 데이터(다른 데이터를 기술하기 위해 사용하는 데이터)를관리
• Keycloak 리소스 조회 : $ kubectl get all -n keycloak ✅ Keycloak 은 컨테이너 플랫폼 포털 사용자 인증을 관리
• Keycloak 리소스 조회 : $ kubectl get all -n cp-portal
• Vault Pod 조회 : $ kubectl get pods -n vault ✅ Vault는 인증데이터를 관리
• Vault Pod 조회 : $ kubectl get pods -n chartmuseum
• Vault Pod 조회 : $ kubectl get pods -n chaos-mesh

포털 리소스 삭제

• 배포된 포털 리소스의 삭제를 원하는 경우 아래 스크립트를 실행
• 🚨 포털이 운영되는 상태에서 해당 스크립트 실행 시, 운영에 필요한 리소스가 모두 삭제되므로 주의 필요

  $ cd ~/workspace/container-platform/cp-portal-deployment/script 
  $ chmod +x uninstall-cp-portal.sh 
  $ ./uninstall-cp-portal.sh 
  Are you sure you want to delete the container platform portal? <y/n> y

1. K-PaaS 컨테이너 플랫폼 클러스터 배포과정을 이해한다.
2. K-PaaS 컨테이너 플랫폼 포털 서비스의 배포과정과 주요 기능을 이해한다.
3. K-PaaS 컨테이너 플랫폼 파이프라인 서비스, 소스 컨트롤 서비스의 배포과정과 주요 기능을 이해한다.

Container Platform 설치 개요

K-PaaS 가이드 문서 컨테이너 플랫폼(CP) 설치 가이드 컨테이너 플랫폼(CP) 사용 가이드

클러스터 설치 준비

✅ 머신 당 deb / rpm 호환 Linux OS (Ubuntu 22.04)가 설치되어야 함 ✅ 머신 당 16G 이상의 RAM (최소사양 8G) ✅ 머신 당 4개 이상의 CPU (최소사양 2개) ✅ 클러스터의 모든 시스템 간의 완전한 네트워크 연결 (인터넷 환경 양호)

방화벽 정보 (필수 설정)

Control Plane 노드

Worker 노드

K-PaaS 지원 스토리지 정보 (필수 설정)

• K-PaaS 컨테이너 플랫폼 클러스터 설치 전 스토리지를 선택
  • ✅ NFS
    • NFS Server 설치 가이드 제공
    • 클러스터 설치 전에 신규 인스턴스 생성하여 NFS Server 설치 필요
  • ✅ ceph
    • ROOK을 통한 배포 단순화
    • 기존 인스턴스에 볼륨 추가

쿠버네티스 서비스 External IP 설정 (필수 설정)

• ✅ K-PaaS 컨테이너 플랫폼 서비스 구성을 위해 특정 서비스에 External IP 설정 필요

로드밸런서 (HA Control Plane 구성 시 필수 설정)

• ✅ HA Control Plane 구성이 아닐 경우 로드밸런서 구성 과정은 생략하고 다음 과정을 진행

클러스터 설치

클러스터 설치 과정

• 환경구성 > NFS 서버설치 > SSH key 생성 및 배포 > Deployment 다운로드 > 환경변수 입력 > 쉘스크립트 배포 > 설치 확인

SSH 생성 및 배포

• 클러스터 설치를 위해 인벤토리의 모든 서버들에 SSH Key 복사, 붙여넣기
• ✅ RSA 공개키를 이용하여 SSH 접속 설정
• SSH Key 생성 및 배포 이후의 모든 설치과정은 Control Plane 노드에서 진행

1. Control Plane 노드에서 RSA 공개키 생성 ssh-keygen -t rsa -m PEM -N '' -f $HOME/.ssh/id_rsa
2. RSA 공개키 출력 및 복사 cat ~/.ssh/id_rsa.pub
3. Control Plane, Worker 노드의 authorized_keys 파일 본문의 마지막 줄 하단에 공개키 붙여넣기 (🔔 Control plane 수 + Worker 노드 수만큼 반복) vi .ssh/authorized_keys

Deployment 다운로드

• 클러스터 설치에 필요한 Deployment를 다운로드 후 설치 작업 경로로 이동하여 설치
• ✅ 이 단계부터는 Control Plane 노드에서만 진행

1. 클러스터 Deployment를 다운로드하여 설치 작업경로에 위치 Kubespray Download URL
2. git clone 명령을 통해 다음 경로에서 클러스터 Deployment 다운로드 진행 가능 git clone https://github.com/K-PaaS/cp-deployment.git 0b branch_v1.5.x

환경변수 정의

• 클러스터 설치에 필요한 환경변수를 사전 정의 후 쉘 스크립트를 통해 설치 진행

1. 클러스터 설치경로로 이동 cd ~/cp-deployment/single
2. 클러스터 설치에 필요한 환경변수 정보를 입력 vi cp-cluster-vars.sh

쉘스크립트 배포

• 쉘 스크립트를 통해 필요 패키지 설치, 클러스터 설치 환경변수 설정, Ansible playbook을 통한 컨테이너 플랫폼 클러스터 설치를 순차적으로 진행

1. 쉘 스크립트를 통해 설치 진행 source deploy-cp-cluster.sh

클러스터 정상 설치 확인

• 노드 및 kube-system 네임스페이스의 Pod를 확인하여 클러스터 설치 확인

1. Kubernetes Node 확인 kubectl get nodes
2. kube-system Namespace의 Pod 확인 kubectl get pods -n kube-system

Kubespray

• kubernetes 설치를 지원하는 자동화 도구
• ansible을 통해 구축하고자 하는 설정값만 맞게 변경하면 됨

Kubernetes

• 컨테이너화된 앱을 자동으로 배포, 스케일링 및 관리해 주는 오케스트레이션 도구

CRI-O

• Kuberenetes를 위한 표준(OCI) 컨테이너 런타임 인터페이스(Container Runtime Interface)

Calico

• Container, VM 환경에서 L3기반 Virtual Network 구축을 지원하는 도구

Metal LB

• Kubernetes의 Service를 LoadBalancer 타입으로 서비스할 수 있도록 해주는 솔루션

NGINX Ingress Controller

• Kubernetes 및 컨테이너화된 환경의 클라우드 네이티브 앱을 위한 트래픽 관리 솔루션

Helm

• Kubernetes용으로 구축된 SW를 제공, 공유 및 사용할 수 있는 오픈소스 패키지 매니저

Istio

• 오픈소스 기반의 분산형 마이크로서비스 기반 앱을 어디서나 실행할 수 있도록 지원하는 서비스 메시

Podman

• 오픈소스 기반의 Linux 시스템에서 컨테이너를 개발, 관리, 실행하기 위한 도구

OpenTofu

• 클라우드 환경에서 인프라 관리를 단순화하는 오픈소스 코드 프로비저닝 도구

NFS

• 네트워크를 통해 다른 호스트에 있는 파일을 공유해 사용할 수 있도록한 분산 파일 시스템

Rook Ceph

• 높은 확장성과 다양한 스토리지 프로토콜 인터페이스 지원하는 오픈소스 분산 스토리지 시스템

포털 구성 소프트웨어

Vault

• 신원 기반 시크릿 및 암호화 관리 시스템

Harbor

• 오픈소스 기반의 컨테이너 이미지를 관리하는 기능을 구현한 레지스트리

MariaDB

• 오픈소스 기반의 관계형 DB 관리 시스템(RDBMS)

Keycloak

• 오픈소스 기반의 IAM(Identity and Access Management) SW

ChartMuseum

• Chart를 ChartMuseum에 저장해 놓고서 불러와서 사용할 수 있는 레파지토리

Chaos Mesh

• 클라우드 네이티브 환경을 위한 오픈소스 카오스 엔지니어링 플랫폼

Container

• 가상화된 OS 위에서 애플리케이션의 독립적인 실행에 필요한 파일(소스코드, 라이브러리 등)을 모은 패키지
• 애플리케이션의 코드를 관련 구성 파일, 라이브러리 및 앱 실행에 필요한 종속성과 함께 번들로 제공하는 SW 패키지

Hypervisor 기술과 Container 기술

• Hyperviosr 기술은 물리적인 서버 위에서 각각의 OS를 구성하여 그 위에 애플리케이션을 운영하는 구조
• Container 기술은 OS 레벨에서 프로세스를 격리하는 가상화 기술
• 안전성이 중요한 환경에서는 Hypervisor (VM)
• 빠른 배포와 경량 운영이 필요한 환경에서는 Container
• 최근에는 하이브리드 환경(VM + Container)도 많이 사용됨 (예: Kubernetes on VMware)

Container 특징

• 개발과 운영의 관심사 분리
• 지속적인 개발, 통합 및 배포
• 기민한 앱 생성과 배포
• 가시성(observability)
• 개발, 테스팅 및 운영 환경에 걸친 일관성
• 클라우드 및 OS 배포판 간 이식성
• 앱 중심 관리

Container Engine

• 컨테이너를 관리하기 위한 API나 CLI 도구를 제공하는 SW
• 사용자 입력을 받고, 컨테이너 이미지를 꺼내고(pull), 컨테이너 실행 방법을 명시한 메타데이터를 만든 다음, 컨테이너 런타임에 이 정보들을 전달

Container Runtime

• 루트 파일시스템과 메타 데이터(spec file)를 받아 컨테이너를 실행하는 도구

Podman 이해

Podman

• 리눅스 시스템에서 컨테이너 및 컨테이너 이미지를 실행, 관리, 배포할 수 있도록 설계된 Daemonless 컨테이너 엔진

Podman과 Docker의 차이

1. Podman은 데몬이 없고(Daemonless), Docker는 데몬(dockerd)이 항상 실행됨.
2. Podman은 rootless 모드를 기본 지원하여 보안성이 더 뛰어남.
3. Docker는 docker-compose 기본 지원, Podman은 podman-compose를 추가 설치해야 함.
4. Podman은 Kubernetes YAML을 쉽게 생성 가능 (podman generate kube).
5. Podman과 Docker는 거의 동일한 명령어를 사용하며, Docker 이미지를 그대로 사용할 수 있음.

✅ Docker는 익숙한 환경, Podman은 보안성과 유연성이 중요한 환경에서 사용하면 좋음! 🚀

Podman CLI

• Podman 명령은 Docker-CLI와 유사한 CLI를 사용. 대부분 추가 권한 없이 일반 사용자로 실행 가능
• podman version Podman 버전 정보 표시
• podman login(또는 logout) 컨테이너 레지스트리에 로그인/로그아웃
• podman build 컨테이너 파일을 사용하여 컨테이너 이미지 빌드
• podman tag 로컬 이미지에 새로운 이름 추가
• podman pull 레지스트리에서 이미지 가져오기
• podman push 이미지, 매니페스트 목록 또는 이미지 인덱스를 로컬 스토리지에서 다른 곳으로 보내기
• podman run 컨테이너 이미지로 새 컨테이너 실행
• podman exec 실행 중인 컨테이너에서 명령 실행
• podman stop 실행 중인 컨테이너 중지
• podman kill 실행 중인 컨테이너 즉시 종료
• podman ps 컨테이너에 대한 정보 출력
• podman rm 컨테이너 삭제

Kubernetes 이해

쿠버네티스

• 컨테이너화된 애플리케이션을 자동으로 배포, 스케일링 및 관리해 주는 오픈소스 시스템
• 컨테이너화된 워크로드와 서비스를 관리하기 위한 이식성이 있고, 확장가능한 오픈소스 플랫폼

쿠버네티스 특징

• 서비스 디스커버리와 로드 밸런싱
• 스토리지 오케스트레이션
• 자동화된 롤아웃과 롤백
• 자동화된 빈 패킹(bin packing)
• 자동화된 복구(self-healing)
• 시크릿과 구성 관리

쿠버네티스 클러스터 구성

• Cluster 컨테이너화된 앱을 실행하기 위한 일련의 노드 머신의 집합
• Master 클러스터 전체를 컨트롤하며 내부에 있는 모든 노드를 관리하는 가상 머신
• Worker 마스터에 의해 명령을 받고 실제 컨테이너들이 생성되고 일을 하는 가상 머신

Container Runtime Interface (CRI)

• 컨테이너 런타임 인터페이스는 쿠버네티스에서 다양한 컨테이너 런타임을 사용할 수 있게 해주는 API

Kubernetes 배포 도구

• kubeadm 일반적인 서버 클러스터 환경에서도 쿠버네티스를 쉽게 설치할 수 있게 해주는 관리 툴로서 클러스터를 빠르고 일관되게 설정할 수 있음
• kops 자동화된 프로비저닝 시스템으로 AWS에 쉽고 빠르게 쿠버네티스 클러스터를 설치 가능
• Kubespray Ansible을 통해 쿠버네티스 클러스터를 유연하고 쉽게 배포 및 관리할 수 있는 강력한 오픈 소스 툴

Kubernetes 리소스 개념

Namespace

• 클러스터를 논리적으로 분리하여 사용하는 것을 의미

Deployment

• 레플리카셋을 관리하면서 실행시켜야 할 파드의 배포 및 관리를 하는 리소스
• 상태가 없는 앱을 배포할 때 사용되는 가장 기본적인 컨트롤러
• 파드 개수 유지
• 배포 시 롤링 업데이트 발생

ReplicaSet

• 파드의 개수를 유지하고 관리하는 리소스
• 실행되는 파드를 안정적으로 유지
• 파드 개수에 대한 가용성 보장

Pod

• 실제로 컨테이너가 파드에서 실행되며 컨테이너를 돌리는 최소한의 단위
• 컨테이너가 직접 실행되는 장소
• 하나 이상의 컨테이너 그룹
• 컨테이너를 직접 관리하지 않고 파드 단위로 관리

Service

• 클러스터 외부에서 클러스터 내부 파드에 접근할 수 있도록 IP를 제공하는 리소스
• 고정된 IP주소 할당
• 파드 간의 로드 밸런싱 지원
• 하나 또는 여러 개의 포트 지원

Volume

• 파드의 일부분으로 동일한 파드 내의 컨테이너끼리는 볼륨 공유가 가능하며 컨테이너의 데이터를 보관하여 유지시키는 역할

Ingress

• 클러스터 외부로부터 클러스터 내부로 들어오는 네트워크 트래픽을 로드밸런싱
• L7 로드밸런싱 기능을 수행
• Service에 외부 URL을 제공
• 클러스터로 접근하는 URL 별로 다른 서비스에 트래픽을 분산
• TLS/SSL 인증서 처리
• 도메인 기반의 Virtual hosting을 지정

StatefulSet

• 동일한 컨테이너 스펙을 가진 파드들을 관리하며 각 파드들은 각각의 식별자를 가지기 때문에 독자성을 유지
• 파드들의 순서 및 고유성을 보장
• 식별자를 가지고 있어 재스케줄링 간에도 지속적인 유지
• 내부 파드마다 고유한 pvc를 갖도록 설정이 가능하여, 스케일 확장 시 PV를 유지 가능

Deployment vs StatefulSet

Job

• 여러 파드를 지정하여 지정된 파드를 성공적으로 실행하도록 하는 설정

CronJob

• JOB을 실행하는데 스케줄러 역할

DaemonSet

• 클러스터 전체에 특정 파드를 실행할 때 사용하거나 특정 노드 또는 모든 노드에 항상 실행되어야 할 특정 파드들을 관리

Persistent Volume

• 특정 파드와 상관없이 별도의 생명주기를 가지는 독립적인 볼륨

Persistent Volume Claim

• 사용자가 PV(Persistent Volume)에 하는 요청
• 파드와 PV를 연결

StorageClass

• PV로 확보한 스토리지 종류를 정의하는 리소스

PV, PVC 생명주기

1. 생성 (Provisioning)
2. 연결 (Binding)
3. 사용 (Using)
4. 삭제 (Reclaiming)

💻 Kubectl

• 쿠버네티스 API를 사용하여 쿠버네티스 클러스터의 컨트롤 플레인과 통신하기 위한 CLI
• kubectl apply -f FILENAME 파일이나 표준입력(stdin)으로부터 리소스에 구성 변경 사항을 적용
• kubectl create -f FILENAME 파일이나 표준입력에서 하나 이상의 리소스를 생성
• kubectl get 하나 이상의 리소스를 조회
• kubectl describe -f FILENAME 하나 이상의 리소스의 상세한 상태 조회
• kubectl logs 특정 이름을 가진 리소스의 로그 정보 출력
• kubectl edit 특정 이름을 가진 리소스 정보 수정

Kubernetes 리소스 관리

📝 Deployment yaml 파일 작성 방법

apiVersion: v1           # Kubernetes API 버전
kind: Pod                # 생성할 오브젝트 종류 (Pod)
metadata:                # 리소스에 이름을 부여하고 구분
  name: my-pod           # Pod의 이름
  labels:                # 키-값 쌍으로 구성
    app: my-app          # 라벨 (Pod 식별용)
spec:                              # 생성하고자 하는 리소스에 대한 내용 구체적 정의
  replicas: 3                      # 띄우고자 하는 파드 개수
  selector:                        # 어떤 파드를 컨트롤하고 감시해야 하는지 정의
    matchLabels:                   # metadata.labels와 동일한 설정으로 맵핑. 동일한 레이블 가진 파드의 컨테이너를 카운팅하여 현재 상태를 측정
      app: my-app                  # 레이블 셀렉터: app이 'my-app'인 Pod들만 선택
  template:                        # 어떤 파드를 실행할지에 대한 정보 설정
    metadata:                      # metadata.labels와 동일한 설정으로 맵핑. 동일한 레이블 가진 파드 실행
      labels:
        app: my-app                # Pod에 붙일 레이블
    spec:                          # 실행시킬 컨테이너에 대한 설정
      containers:                  # 실행시킬 컨테이너의 이름, 이미지, 포트 번호 등을 설정
      - name: my-container
        image: nginx:latest        # 컨테이너로 배포할 이미지 지정
        imagePullPolicy: Always    # 이미지 다운로드 정책 지정
        ports:
        - containerPort: 80        # 컨테이너에서 노출할 포트
      imagePullSecrets:            # 이미지 저장소에 접근하기 위한 인증정보
      - name: edu-msa-secret
      nodeSelector: kubernetes.io/hostname: paas-ta-worker-1 # 파드를 배포할 특정 노드 지정

📝 서비스 yaml 파일 작성 방법

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app                    # 이 서비스가 연결할 Pod의 레이블
  ports:
    - nodePort: ${EDU_MSA_BOARD}   # 외부에서 접근 가능한 포트 번호 설정 (외부 포트)
      port: 80                     # 서비스가 클러스터 내에서 사용하는 포트 (내부 포트)
      protocol: TCP                # 프로토콜 방식 설정
      targetPort: 8080             # 접근하고자 하는 컨테이너 포트 번호를 설정
  type: NodePort                   # 외부에 노출하고자 하는 방식 설정 (NodePort는 포트 번호를 통해 외부에서 접근할 수 있는 방법)

🔔 서로 연관된 여러 yaml 파일을 하나의 파일로 작성하기 위해서는 중간에 ---로 구분 지어 작성

1. K-PaaS에 대해 이해할 수 있다
2. 표준모델인 컨테이너 플랫폼에 대해 이해할 수 있다
3. 컨테이너 플랫폼을 구성하는 주요 요소를 이해할 수 있다
4. 컨테이너 플랫폼을 관리하는 주요 도구를 이해할 수 있다

Container Platform 소개

K-PaaS

• 클라우드 인프라 위에서 SW나 서비스를 개발·실행·운영·관리하는 기반 SW 환경 (미들웨어 성격)

Container Platform

• 쿠버네티스 기반의 단독 배포, 서비스형 배포 및 Edge 배포 기능을 구현하여 클라우드 기반 서비스 및 운영에 필요한 부가 서비스를 지원하는 오픈소스 PaaS 플랫폼
• Kubernetes Cluster 및 운영에 필요한 Storage 서버로 구성하고, Description을 기반으로 컨테이너화 된 애플리케이션을 배포하는 방식으로 동작

Container Platform 배포방식

단독형 배포

• 컨테이너 플랫폼을 단독으로 배포하여 독립된 쿠버네티스 환경을 제공하는 배포 방식

Edge 배포

• Edge Computing 기반 배포 방식으로 단독 배포와 같이 쿠버네티스 클러스터를 Edge 환경에 단독으로 배포하여 독립된 쿠버네티스를 제공하는 배포 방식

서비스형 배포

• 컨테이너 플랫폼을 애플리케이션 플랫폼에서 서비스 형태로 쿠버네티스 클러스터를 등록하여 사용하는 방식

Container Platform 기능 특징

2024 버전 특징

• 멀티 클라우드 구성 지원
  • 서비스 메시(Istio)를 이용한 멀티 클라우드 환경 서비스 지원
  • 서비스 메시(Linkerd)를 이용한 멀티 클라우드 환경 서비스 지원
  • 클러스터 페더레이션을 이용한 멀티 클라우드 환경 서비스 지원
  • 멀티 클라우드 패키징 추가, 다양한 환경에 맞는 Deployment 제공
• 포털 서비스를 통한 클러스터 생성 및 멀티 클러스터 관리 지원

K-PaaS = K-PaaS 표준모델 + K-PaaS 적합성 인증 PaaS/플랫폼 SW

K-PaaS 표준모델

• 상호운용성 및 호환성을 보장하는 오픈 클라우드 플랫폼

K-PaaS 적합성 인증 PaaS/플랫폼 SW

• K-PaaS 플랫폼을 지원하면서 추가 기능들로 확장하였음을 인증받은 제품이나 서비스

K-PaaS 기대효과

• HW자원의 효율적인 활용
• SW자원의 신속한 제공
• 간편한 SW 유지보수
• 안정적인 시스템 운영
• 클라우드 이동성 확보

K-PaaS 표준모델

지원 기능

• 플랫폼
• 서비스
• 운영도구
• 개발도구

K-PaaS 특징

• 인프라 종속 탈피
• 국산 SW 서비스 지원
• 풍부한 개발운영 환경
• CF-KBS 듀얼 통합 환경
• 보안성 강화
• 마켓 플레이스
• 통합 모니터링
• 자동·확장 및 장애복구

개방형 클라우드 플랫폼 센터 소개

센터 소개

• 고도화 및 유지·관리
• 플랫폼 생태계 활성화 지원
• 적용·확산을 위한 전문기술지원
• 클라우드 플랫폼 전문가·기업 육성

클라우드 네이티브 클라우드의 이점을 최대로 활용할 수 있도록 애플리케이션을 구축하고 실행하는 방식

클라우드 컴퓨팅 모델의 장점을 활용할 수 있도록 애플리케이션을 개발하고 실행하기 위한 접근 방식

핵심은 '서비스'

• 최소의 상태(stateful) 컴포넌트들이 격리된 상태의 마이크로서비스로 구성되며, 각각의 서비스는 분산되고, 탄력적이며 수평적 확장성 있는 시스템으로 구성
• 애플리케이션과 각각의 독립적인 배포단위는 클라우드중심의 디자인패턴들과 셀프서비스가 가능한 탄력적인 플랫폼*에서 운영되도록 설계
• 애플리케이션을 서로 독립적인 기능을 하는 여러 개의 서비스로 구분
• 서비스들을 어떻게 구성, 연결, 관리하는지가 핵심요소
• ‘서비스’들을 묶어 하나의 통합된‘(비즈니스) 서비스’로 만드는 다양한 기능과 기술필요

핵심요소

• Microservices 안정성, 스케일링 용이성 개선
• Container IT 이식성, 유연성 확보
• DevOps APP 서비스 개선 속도 증가
• CI/CD 개발-운영간 업무 속도 증가

아키텍처

개발방식

특징

예시

효과

MicroService Architecture

MSA 대규모 SW 개발에 적용하기 위한 것. 단독으로 실행 가능하고 독립적으로 배치될 수 있는 작은 단위(모듈)로 기능을 분해하여 서비스하는 아키텍처

마이크로서비스 간 연결은 응용 프로그래밍 인터페이스(API)를 이용 마이크로서비스는 자원 표현이나 데이터 관리 등에 있어 기능적으로 완전해야 함

REST API

• 두 컴퓨터 시스템이 인터넷을 통해 정보를 안전하게 교환하기 위해 사용하는 인터페이스

REST

• 자원의 표현에 의한 상태 전달
• 자원(Resource) - URI
• 행위(Verb) - HTTP Method
• 표현(Representation) - Client가 자원의 상태(정보)에 대한 조작을 요청하면 Server는 이에 적절한 응답(Representation)을 보냄(JSON, XML, TEXT, RSS 등 여러 형태)

MSA 특징

• One Thing 한 가지 기능을 수행하는데 초점
• Small 가장 작은 단위의 서비스
• API 다른 서비스와 연계
• Autonomous 각자 자율 개발

장점

• 분산형 개발을 통해 개발자들이 동시 참여 가능하고, 유연하고 빠른 의사결정이 가능 => 개발 소요시간 단축
• 모놀리식 애플리케이션과는 달리, 한 부분에 장애가 발생하더라도 전체 애플리케이션이 중단되지 않음
• 빠르고 유연한 조직문화 기여
• 출시 시간 단축
• 유연한 확장
• 뛰어난 복구 능력
• 개발자 생산성 증가
• 높은 신기술 수용력

단점

• 모놀리식 아키텍처에 비해 구조가 복잡함. 서비스 간 통신에 대한 처리가 추가적 필요. 개발, 배포, 운영 측면에서 고려해야 할 사항 증가
• 개발, 운영 복잡성 증가
• 통합 테스트 어려움
• 배포, 운영을 위한 자동화 필요
• 코드 중복성
• 트랜잭션 처리 어려움
• 디버깅 어려움

Container

컨테이너

• 가상화된 OS 위에서 애플리케이션의 독립적인 실행에 필요한 파일(소스코드, 라이브러리 등)을 모은 패키지
• Cloud Native 소프트웨어의 가장 작은 단위
• 서버에 바로 배포할 수 있을 뿐 아니라, 가상머신 위에도 배포 가능
• OS를 통해 관리되며 리소스 및 기능에 제약을 가지는 구동 프로세스(running process)

특징

• 이식성을 바탕으로 작고, 가볍고, 손쉽게 애플리케이션 배포 가능

DevOps

DevOps

• 기존의 개발업무와 운영업무로 나누어진 두 역할 사이의 커뮤니케이션, 협업, 통합
• 프로세스 자동화를 목표로 개발자와 운영자가 협업하여, 짧은 주기 내 신뢰성 있는 소프트웨어 생성, 테스트, 릴리즈 할 수 있는 문화와 환경을 의미
• 애플리케이션 개발-운영 간의 협업 프로세스를 자동화하여 개발과 개선 속도를 빠르게 함

특징

• 속도 및 신속한 제공 릴리즈 빈도, 속도를 개선
• 안전성 변경 사항이 제대로 안전하게 작동하는지 테스트 가능
• 확장 및 보안 규모에 따라 인프라와 개발 프로세스 운영, 관리 가능
• 협업강화

DevOps 도입을 위한 필수요소

• 애자일
• CI/CD 지속적 통합, 배포

CI/CD

CI/CD

• 지속적인 통합, 서비스 제공, 배포의 자동화를 통해 더욱 짧은 주기로 고객에게 App 제공하는 방법
• 지속적인 통합 / 지속적인 배포 Continuous Integration / Continuous Delivery or Deployment

CI

• 앱 코드의 새 변경사항이 정기적으로 빌드 및 테스트를 거쳐 공유 리포지토리에 병합되는 것을 의미

CD

• 지속적인 서비스 제공(Delivery)은 개발자들이 앱에 적용한 변경 사항이 버그 테스트를 거쳐 리포지토리에 자동으로 업로드되는 것을 의미
• 지속적인 배포(Deployment)는 개발자가 변경한 사항을 리포지토리에서 고객이 사용 가능한 프로덕션 환경까지 자동으로 릴리스되는 것을 의미

CI/CD와 DevOps 관계

• DevOps는 SW 개발 효율성 향상을 목표하는 문화이자 프로세스
• CI/CD는 DevOps를 실현하기 위해 필수적인 방법 요소

return CommUtil.doComplete(model, "오류", "정상적인 경로로 접속 해 주세요", "history.back();");

해당 코드로 처리한다.

    /**
     * 처리 완료 후 안내문구 및 스크립트 설정,
     * @param model ModelMap
     * @param title : 페이지 타이틀 제목 (보통 오류또는 안내)
     * @param msg : alert() 경고 문으로 보여줄 안내문, "" 값이면 경고창 없음
     * @param script : javascript 처리문장 (보통 location.href='~~~~')
     * @return /ncms/comm/message/message
     */
    public static String doComplete(ModelMap model, String title, String msg, String script) {
        HashMap<String, String> message = new HashMap<String, String>();
        message.put("title",title);
        message.put("msg",msg);
        message.put("script",script);
        message.put("type","alert");
        model.addAttribute("message", message);

        return "/ncms/comm/message/message";
    }

    /**
     * 처리후 confirm 함수를 이용해 사용자 선택을 받아서 처리 함
     * @param model
     * @param title 제목
     * @param msg confirm 질문 내용
     * @param okUrl [확인]버튼 클릭시 스크립트
     * @param cancelUrl [아니오]버튼 클릭시 스크립트
     * @return
     */
    public static String doCompleteConfirm(ModelMap model, String title, String msg, String okUrl, String cancelUrl) {
        HashMap<String, String> message = new HashMap<String, String>();
        message.put("title",title);
        message.put("msg",msg);
        message.put("script","");
        message.put("okUrl",okUrl);
        message.put("cancelUrl",cancelUrl);
        message.put("type","confirm");
        model.addAttribute("message", message);
        return "/ncms/comm/message/message";
    }

return jsp는 아래와 같다.

<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ taglib prefix="ui" uri="http://egovframework.gov/ctl/ui"%>
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>

<style>body{display:none;visibility:hidden;}</style>
<script>
<c:if test="${not empty message.title}">
document.title = "${message.title}";
</c:if>
<c:choose>
    <c:when test="${message.type eq 'alert'}">
        <c:if test="${message.msg != ''}">
        alert("<c:out value="${message.msg}"/>");
        </c:if>
        <c:out value="${message.script}" escapeXml="false" />
    </c:when>
    <c:when test="${message.type eq 'confirm'}">
        <c:if test="${message.msg != ''}">
        if (confirm("<c:out value="${message.msg}"/>")) {
            <c:out value="${message.okUrl}" escapeXml="false" />
        } else {
            <c:out value="${message.cancelUrl}" escapeXml="false" />
        }
        </c:if>
        <c:out value="${message.script}" escapeXml="false" />
    </c:when>
    <c:otherwise>
        <c:if test="${message.msg != ''}">
        alert("<c:out value="${message.msg}"/>");
        </c:if>
        <c:out value="${message.script}" escapeXml="false" />
    </c:otherwise>
</c:choose>
</script>

서비스 모델 구분 예시

• On-premises solution (개인 차 소유)
• IaaS (렌트카 이용)
• PaaS (택시 이용)
• SaaS (버스 이용)

Public Cloud (비안유확)

• 서비스 제공업체가 구축한 서버, 스토리지 등의 IT 인프라를 기업들이 사용료를 내고 이용하는 방식
• 비용 절감 (사용한 서비스에 대해서만 지불)
• 유지관리 하지 않음 (서비스 공급자가 유지관리)
• 높은 안정성 (광대한 서버 네트워크)
• 무제한에 가까운 확장성 (주문형 리소스 사용 가능)

Private Cloud (유보확)

• 기업 자체적으로 데이터센터 안에 클라우드 환경을 구축해 사용하는 방식
• 유연성 향상 (클라우드 환경을 사용자 지정 가능)
• 보안 강화 (제한과 보안 수준 강화 가능)
• 높은 확장성 (공용 클라우드의 확장성과 효율성 제공 가능)

Hybrid Cloud (제유비용)(이기종)

• On-Premise 인프라 (또는 Private 클라우드)를 Public 클라우드와 결합하여 사용
• 제어 (직접 유지관리)
• 유연성 (추가 리소스 활용 가능)
• 비용 효율성 (규모 조정 가능. 필요시에만 추가 컴퓨팅 기능에 대해 지불 가능)
• 용이성 (부담 없이 클라우드 전환 가능)

Multi Cloud (동종)

• 공급업체 종속으로 인한 리스크 대응 가능
• 최신기술 도입 적용을 통한 서비스 개선 가능
• 클라우드 서비스 조합을 통해 가격경쟁력 확보
• 기업 전략에 따른 여러 클라우드 서비스 이용

IaaS

Infrastructure as a Service (서비스형 인프라) 물리적 리소스를 가상화하여 유연한 Infrastructure 제공

PaaS

Platform as a Service (서비스형 플랫폼) PaaS는 미들웨어 성격을 띠며, 컨테이너를 기반으로 SW 플랫폼 서비스를 제공 IaaS와 SaaS의 중간 수준의 서비스

특징

• IaaS 기반에서 SaaS 개발 시의 문제점을 해결 가능
• 표준화된 HW 및 SW의 설치구성을 자동화하여 신속한 개발·테스트 가능
• 애플리케이션을 개발, 실행, 관리할 수 있는 플랫폼을 제공하는 서비스
• SaaS의 개념을 개발 플랫폼에 확장한 방식
• 개발을 위한 플랫폼 구축 필요 없이 웹에서 쉽게 빌려 쓸 수 있음
• 개발자는 개발에만 집중, 애플리케이션이 동작하는 주변 환경은 가져다 쓰는 구조
• 개발 to 배포까지 라이프사이클이 짧아 DevOps 문화를 적용하기 용이함

SaaS

Software as a Service (서비스형 소프트웨어) IaaS, PaaS 환경 위에서 SW기능을 서비스로 제공 필요한 만큼만 이용하고 요금을 지불하는 형태

특징

• 인터넷에만 접속하면 별도 설치 없이 바로 사용가능
• 구독형 서비스
• 이용 규모·기간이 고정적이지 않아 단기간·소수 계정만으로도 사용 가능
• 데이터가 클라우드에 저장되어 보안성이 높고 접근이 자유로움
• 수시로 최신 버전 사용 가능
• 클라우드 공급자가 대신 관리하므로 유지관리에 소요되는 리소스 비용이 없음

1. 클라우드 컴퓨팅 기술의 기본속성, 발전과정 및 최신동향을 이해
2. 클라우드 컴퓨팅 서비스를 구분하는 유형과 유형별 특징을 이해
3. 클라우드 네이티브 애플리케이션의 개념과 MSA, 컨테이너, DevOps, CI/CD 등 주요 개념 이해
4. K-PaaS의 개발배경 및 아키텍처를 이해, 최신 버전의 특징 이해

Cloud 개요

클라우드 컴퓨팅 네트워크 기반 컴퓨팅 기술

컴퓨팅 리소스를 데이터센터에 대량으로 집적 시킨 후, 개별 이용자가 요구하는만큼 가상으로 분리하여 정보통신망을 통해 제공하는 서비스

인터넷을 통해 서버, 스토리지, DB, 네트워킹, SW 등 컴퓨터 서비스 제공

특징 (주광리신측)

• 주문형 셀프 서비스 (On-demand self-service) 사용자의 개별 관리화면을 통한 컴퓨팅 기능(서버 시간, 네트워크 스토리지 등) 설정
• 광범위한 네트워크 접속 (Broad network access) 다양한 디바이스를 통한 서비스 접속
• 리소스 공유 (Resource pooling) 여러 사용자의 요구에 따라 동적 할당 및 재할당 형태로 이용 가능
• 신속한 확장성 (Rapid elasticity) 스케일 업(처리능력을 높이는 것), 스케일 다운(처리능력을 낮추는 것) 가능
• 측정 가능한 서비스 (Measured service) 이용한 만큼 요금을 부과하는 종량제 서비스

Cloud 발전과정

2000년 - 물리서버 2001년 - 가상화 2006년 - IaaS (ex. AWS) 2009년 - PaaS 2010년 - 오픈소스 IaaS (ex. openstack) 2011년 - 오픈소스 PaaS 2013년 - 컨테이너 (ex. docker) 2015년 - 클라우드 네이티브

Edge Computing

• 데이터가 발생한 현장 혹은 근거리에서 실시간 처리하는 방식으로 데이터 흐름 가속화를 지원하는 컴퓨팅 기술

Cloud 산업 동향

세계, 국내 클라우드 서비스 매출은 매년 꾸준히 성장 국내 클라우드 서비스는 IaaS 시장 주도, SaaS 시장 최근 빠르게 성장 글로벌 IT 기업이 세계 IaaS 시장의 75%, SaaS 시장의 35% 점유

Cloud 트렌드

23년 트렌드

• 클라우드 보안 및 복원력 투가 증가
• 멀티클라우드 수요 증가
• AI 및 머신러닝 기반 클라우드
• 로우코드 및 노코드 클라우드 서비스 (LCNC)
• 클라우드 게임

24년 트렌드

• 업무망 활용 등 공공분야 SaaS 도입 가속화
• 기술 중심 '클라우드 네이티브'로의 전환
• 클라우드 특화 보안 전략 채택
• 금융권 핵심업무시스템 클라우드 촉진
• AI GPU 고수요 지속

25년 트렌드

• AI가 클라우드 컴퓨팅의 두뇌가 되다
• 엣지 컴퓨팅과 클라우드의 융합
• 클라우드를 통한 양자 컴퓨팅의 대중화
• 새로운 클라우드의 표준, 하이브리드 & 멀티
• 생성형 AI가 클라우드 개발을 혁신하다
• 슈퍼 클라우드가 궁극적인 데이터 패브릭으로 등장하다
• 지속 가능성이 클라우드의 필수가 되다

코드 가독성 향상

help - install new software

http://kiritsuku.github.io/IndentGuide/update/

window - preference - editors - text editors - indent guide

edit box

코드 가독성 향상

help - install new software

http://editbox.sourceforge.net/updates

more clipboard

복사한 것들을 여러 개 가지고 있을 수 있음 Ctrl + Shift + V

ajax error 확인 방법

$.ajax({
    url: url,
    type: 'get',
    dataType: 'json', 
    contentType : "application/json",
    success: function(data){
    }
    error: function(request, status, error){
          console.log("code:"+request.status+"\n"+"message:"+request.responseText+"\n"+"error:"+error);
    }
});

위와 같이 작성하면 ajax error 시 왜 에러가 발생했는지 알 수 있다.

또는,

$.ajax({
    url: url,
    type: 'get',
    dataType: 'json', 
    contentType : "application/json",
    success: function(data){
    }
    error: function(request, status, error){
      var errorMsg = 'status(code): ' + request.status + '\n';
      errorMsg += 'statusText: ' + request.statusText + '\n';
      errorMsg += 'responseText: ' + request.responseText + '\n';
      errorMsg += 'textStatus: ' + status + '\n';
      errorMsg += 'error: ' + error;
      console.log(errorMsg);
    }
});

참고

[ JQUERY ] ajax 사용 시 error 발생 확인 [Javascript] ajax error 확인