gitignore 설정

gitignore 파일 설정 사이트 (https://url.kr/8mzhtv) > intellij,eclipse,gradle 옵션 추가

new Project : spring initializer

spring boot는 spring framework를 빠르게 사용하기 위한 노력의 결과물입니다. spring boot를 이용해서 기본구조를 빠르게 만들어서 쉽게 프로젝트를 시작하려고 합니다.

1. 인텔리 제이의 new project 버튼 클릭
2. 프로젝트 파일 기본 설정

   

• 프로젝트 종류
  • Maven Project
  • Gradle Project
• 개발 언어
  • java
  • Kotlin
  • Groovy
• spring boot 버전
• project meta data
• dependencies

  프로젝트 생성시, 위 옵션항목별로 프로젝트 구성용도를 설명하자면, : 프로젝트의 종류, 개발언어, meta data의 패키징(Packaging)의 경우

• 어떠한 것을 선택하느냐에 따라 * 프로젝의 파일들의 이름이나 구조가 바뀝니다.

  : 하지만 나머지는 빌드툴(Maven/Gradle)의 설정파일(pom.xml/build.gradle)에 내용이 기입되기 때문에 프로젝트 생성 후 변경해도 무방합니다.

  예시 : dependencies는 스프링 프레임워크에서 제공하는 라이브러리를 사용하기 위한 설정로직입니다. 프로젝트 생성시, 자동으로 빌드툴(Maven/Gradle)의 설정파일(pom.xml,gradle)에 라이브러디 다운로드를 위한 내용이 추가됩니다.

참고 https://url.kr/d9167z : 프로젝트 생성 방법

• 상세 : 버전

• 구현체 찾기 CMD + OPT + Click: Jump to Implementation interface를 구현한 구현체들을 검색해서 이동

• 한글깨짐 인텔리제이 properties 파일에서 한글이 깨져서 나오는 경우가 있다. 이클립스 같은 경우에는 proerties 뷰어 플러그인을 설치해주면 되지만 인텔리제이에서는 설정만 바꿔주면 된다.

1-1. 한줄

⌘D(Ctrl+D) : 라인 복제 (Duplicate current line) ⌘⌫(Ctrl+Y) : 라인 삭제 (Delete line at caret) fn↑,fn↓(PageUp,PageDown): Page Up/Down fn←,fn→(Home, End) : 라인 시작,끝으로 이동 fn⇧←,fn⇧→(Shift+Home,Shift+End) : 라인 전체 선택

1-2. 단어별

⌥↑,⌥↓(Ctrl+W,Shift+Ctrl+W) : 커서 근처의 코드 선택 영역을 확대하거나 축소합니다. ⌥←,⌥→(Ctrl+←,Ctrl+→) : 단어별 포커스 이동 ⌥⇧←,⌥⇧→(Ctrl+Shift+←,Ctrl+Shift+→) : 단어별 선택

2. compile and Run

컴파일(Compile) 및 실행(Run) 관련 주요 단축키 입니다.

⌘F9(Ctrl + F9) : 프로젝트 빌드(Make project) ⌘R(Shift + F10) : 실행 (Run)
⌘d(Shift + F9): 디버그 (Debug)

3. 구조 search

3-1. Method

⌘B(Ctrl+B) : 해당 코드의 선언부로 이동. ⌘⌥B(Ctrl+Alt+B) : 해당 코드의 구현부로 이동.

3-2. method 계층

이제 현재 메서드를 구현하거나 재정의하는 클래스의 전체 계층 구조를 보려면 어떻게 해야 합니까?

3-2-1. 트리 뷰

⌘⌥H(Ctrl+Alt+H) : 클래스의 전체 계층 구조 ⌘⌥U(Ctrl+Alt+U) : 클래스의 전체 계층 구조

3-2-2. 트리뷰 시각화 ( 다이어그램 )

⌘⌥H(Ctrl+Alt+H) : 클래스의 전체 계층 구조

3-3. method 호출 계층

⌥F7(해당 객체 포커스 > Alt+F7) : 메소드를 호출하는 계층 구조

출처: https://ifuwanna.tistory.com/241 [IfUwanna IT] 출처 : https://medium.com/@andrey_cheptsov/top-20-navigation-features-in-intellij-idea-ed8c17075880

• 개발자의 기법에 대한 개발 기대점.
• 용어 차이점 이해 및 설명 삽가능.

2. 프로그래밍 (공통)

• 2.1. 공통 과정
  • 코드를 위에서 아래로 순차적 진행
  • 한번에 한가지 사건만 발생.

2. 동기

• 동기 : 어떤 함수의 결과가 다른 함수가 끝나고 값을 산출할 때까지 대기하는 기법.

3. blocking

3-1. blocking

• 웹 앱이 브라우저에서 특정 코드를 실행하느라 브라우저에게 제어권을 돌려주지 않으면 브라우저는 마치 정지된 것처럼 보일 수 있습니다. 이러한 현상을 blocking 이라고 부릅니다.
  • 어떤 함수의 결과가 다른 함수에 영향을 받는다면, 그 함수는 다른 함수가 끝나고 값을 산출할 때까지 기다려야합니다. 그리고 그 과정이 끝날 때 까지, 유저의 입장에서 보자면, 전체 프로그앰이 멈춘거 같아보입니다.

3-2. blocking 예시 (single thread)

• simple-sync.html

  const btn = document.querySelector('button');
  btn.addEventListener('click', () => {
  let myDate;
  for(let i = 0; i < 10000000; i++) {
    let date = new Date();
    myDate = date
  }
  
  console.log(myDate);
  
  let pElem = document.createElement('p');
  pElem.textContent = 'This is a newly-added paragraph.';
  document.body.appendChild(pElem);
  });
  

• 입력

  • 하나의 버튼에 클릭 이벤트리스너를 지정하여 시간이 오래 걸리는 처리를 하도록하였습니다. (날짜를 천만번 계산하고 마지막에 콘솔에 날짜를 출력합니다.) 그리고 처리가 끝나면 페이지에 간단한 문장을 한 줄 출력합니다. :

• 출력

  • 2-1-출력1 : 콘솔 메세지가 매~우 느림. 이 예제를 실행할 때 JavaScript 콘솔을 열고 버튼을 클릭하면, 콘솔에 메시지가 출력되기 전 까지 페이지에 문장이 나타나지 않는다는 것을 알 수 있습니다. 코드는 위에서 아래로 순차적으로 실행되며, 아래쪽 코드는 위쪽 코드의 처리가 끝날 때 까지 실행되지 않습니다.
  • 2-1-출력2. 버튼 2번클릭시, 출력이 매~우 느림. 첫 번째 버튼을 클릭한 후 두 번째 버튼을 바로 클릭하면 경고 박스가 나타나지 않는 것을 확인할 수 있습니다. 첫 번째 버튼은 이벤트가 끝나기 전 까지 다음 작동을 막아버립니다.

• 원인

  • 왜 이런 현상이 발생할까요? 답은 자바스크립트는 기본적으로 single threaded이기 때문입니다. 이 시점에서 threads의 개념을 소개할 필요가 있겠군요

3-3. Threads

3-3-1. 단일 프로세스

• Thread 는 기본적으로 프로그램이 작업을 완료하는데 사용할 수 있는 단일 프로세스 입니다. 각 스레드는 한 번에 하나의 작업만 수행할 수 있습니다.
  • 결과 :

    Task A --> Task B --> Task C

3-3-2. 멀티 CPU 코어와 멀티 프로세스 :

• 앞서 말했듯이, 많은 컴퓨터들이 현재 여러 개의 CPU코어를 가지고 있기 때문에, 한 번에 여러가지 일을 수행할 수 있습니다. Multiple thread를 지원하는 프로그래밍 언어는 멀티코어 컴퓨터의 CPU를 사용하여 여러 작업을 동시에 처리할 수 있습니다.

• 효과 : 여러작업을 동시 처리

• 결과 :

  Thread 1: Task A --> Task B Thread 2: Task C --> Task D

3-3-3. JavaScript is single threaded

자바스크립트는 전통적으로 싱글 thread입니다. 컴퓨터가 여러 개의 CPU를 가지고 있어도 main thread라 불리는 단일 thread에서만 작업을 실행할 수 있습니다. 위의 예시는 아래처럼 실행됩니다. :

3. 비동기

• 비동기 : 호출한 함수가 바로 리턴해서 호출할,된 함수가 각각 작업에 착수.

참고 [카카오 면접] Blocking I/O, Syncronous Non-Blocking I/O, Asyncronous Non-Blocking I/O

카카오 싱크

차이점

상황1. 카카오 로그인과 카카오 싱크는 전혀 다른 건가요? 현재 저희 회사에서 운영하는 사이트(Web, 모바일Web, 모바일APP(하이브리드))에 카카오 로그인은 적용되어 있는데, 카카오 싱크를 적용하고자 할 경우 어떻게 해야 하는지 전혀 감을 잡지 못하고 있어 문의합니다.

답변 > 카카오싱크는 카카오 소셜 로그인의 확장 스팩으로 이해.

1) 카카오 소셜 로그인으로 제한되는 "사용자 의 개인정보를 추가로 제공 받을 수 있음". 2) 서비스 가입시, 서비스에서 받아야하는 약관을 카카오 동의창에 함께 노출.

목표 :

• 스프링 뿌시기.
• 모듈 구현.
• 모듈 단위로 스프링 확장.

구성 : 계획

• basic 34 : 3일
• topical 3 : 2일
• tutorials 7 : 3일

21.10.08

Building a RESTful Web Service Learn how to create a RESTful web service with Spring.

Scheduling Tasks Learn how to schedule tasks with Spring.

Consuming a RESTful Web Service Learn how to retrieve web page data with Spring's RestTemplate.

Building Java Projects with Gradle Learn how to build a Java project with Gradle.

Building Java Projects with Maven Learn how to build a Java project with Maven.

Accessing Relational Data using JDBC with Spring Learn how to access relational data with Spring.

Uploading Files Learn how to build a Spring application that accepts multi-part file uploads.

Authenticating a User with LDAP Learn how to secure an application with LDAP.

Messaging with Redis Learn how to use Redis as a message broker.

Messaging with RabbitMQ Learn how to create a simple publish-and-subscribe application with Spring and RabbitMQ.

Accessing Data with Neo4j Learn how to persist objects and relationships in Neo4j's NoSQL data store.

Validating Form Input Learn how to perform form validation with Spring.

Building a RESTful Web Service with Spring Boot Actuator Learn how to create a RESTful Web service with Spring Boot Actuator.

Messaging with JMS Learn how to publish and subscribe to messages using a JMS broker.

Creating a Batch Service Learn how to create a basic batch-driven solution.

Securing a Web Application Learn how to protect your web application with Spring Security.

Building a Hypermedia-Driven RESTful Web Service Learn how to create a hypermedia-driven RESTful Web service with Spring.

Accessing Data in Pivotal GemFire Learn how to build an application using Gemfire's data fabric.

Integrating Data Learn how to build an application that uses Spring Integration to fetch data, process it, and write it to a file.

Caching Data with Pivotal GemFire Learn how to cache data in GemFire.

Managing Transactions Learn how to wrap key parts of code with transactions.

Accessing Data with JPA Learn how to work with JPA data persistence using Spring Data JPA.

Accessing Data with MongoDB Learn how to persist data in MongoDB.

Serving Web Content with Spring MVC Learn how to create a web page with Spring MVC and Thymeleaf.

Converting a Spring Boot JAR Application to a WAR Learn how to convert your Spring Boot JAR-based application to a WAR file.

Creating Asynchronous Methods Learn how to create asynchronous service methods.

Handling Form Submission Learn how to create and submit a web form with Spring.

Building an Application with Spring Boot Learn how to build an application with minimal configuration.

Using WebSocket to build an interactive web application Learn how to the send and receive messages between a browser and the server over a WebSocket

Working a Getting Started guide with STS Learn how to import a Getting Started guide with Spring Tool Suite (STS).

Consuming a RESTful Web Service with AngularJS Learn how to retrieve web page data with AngularJS.

Consuming a RESTful Web Service with jQuery Learn how to retrieve web page data with jQuery.

Enabling Cross Origin Requests for a RESTful Web Service Learn how to create a RESTful web service with Spring that support Cross-Origin Resource Sharing (CORS).

Consuming a SOAP web service Learn how to create a client that consumes a WSDL-based service

Accessing JPA Data with REST Learn how to work with RESTful, hypermedia-based data persistence using Spring Data REST.

Accessing Neo4j Data with REST Learn how to work with RESTful, hypermedia-based data persistence using Spring Data REST.

Accessing MongoDB Data with REST Learn how to work with RESTful, hypermedia-based data persistence using Spring Data REST.

Accessing Data in Pivotal GemFire with REST Learn how to work with RESTful, hypermedia-based data persistence using Spring Data REST.

Producing a SOAP web service Learn how to create a SOAP-based web service with Spring.

Caching Data with Spring Learn how to cache data in memory with Spring

Deploying to Cloud Foundry from STS Learn how to deploy a Spring application to Cloud Foundry from STS

Spring Boot with Docker Learn how to create a Docker container from a Spring Boot application with Maven or Gradle

Working a Getting Started guide with IntelliJ IDEA Learn how to work a Getting Started guide with IntelliJ IDEA.

Creating CRUD UI with Vaadin Use Vaadin and Spring Data JPA to build a dynamic UI

Service Registration and Discovery Learn how to register and find services with Eureka

Centralized Configuration Learn how to manage application settings from an external, centralized source

Routing and Filtering Learn how to route and filter requests to a microservice using Netflix Zuul

Testing the Web Layer Learn how to test Spring Boot applications and MVC controllers.

Accessing data with MySQL Learn how to set up and manage user accounts on MySQL and how to configure Spring Boot to connect to it at runtime.

Creating a Multi Module Project Learn how to build a library and package it for consumption in a Spring Boot application

Creating API Documentation with Restdocs Learn how to generate documentation for HTTP endpoints using Spring Restdocs

Messaging with Google Cloud Pub/Sub Learn how to exchange messages using Spring Integration channel adapters and Google Cloud Pub/Sub

Building a Reactive RESTful Web Service Learn how to create a RESTful web service with Reactive Spring and consume it with WebClient.

Consumer Driven Contracts Learn how to with contract stubs and consuming that contract from another Spring application

Accessing Vault Learn how to use Spring Vault to load secrets from HashiCorp Vault

Vault Configuration Learn how to store and retrieve application configuration details in HashiCorp Vault

Accessing Data Reactively with Redis Learn how to reactively interface with Redis and Spring Data

Deploying a Spring Boot app to Azure Learn how to deploy a Spring Boot app to Azure.

Building a Gateway Learn how to configure a gateway

Client-Side Load-Balancing with Spring Cloud LoadBalancer Dynamically select correct instance for the request

Spring Cloud Stream Learn how to build and test Spring Cloud Stream Applications with RabbitMQ and Apache Kafka

Spring Cloud Data Flow Learn how to build, deploy and launch streaming and batch data pipelines using Spring Cloud Data Flow

Spring Cloud Task Learn how to build and test Spring Cloud Task Applications

Spring Boot Kubernetes Deploy a Spring Boot application to Kubernetes

Accessing data with R2DBC Learn how to access relational data with the reactive protocol R2DBC

Spring Cloud Circuit Breaker Guide How to Use Spring Cloud Circuit Breaker

Observability with Spring Learn how to send application metrics to Tanzu Observability

Building a Guide with VS Code Learn how to import and work with a Spring Getting Started Guide in VS Code.

1. 설계

1. 이 가이드는 Spring Boot 애플리케이션을 실행하기 위한** Docker 이미지를 빌드**하는 프로세스를 안내 합니다.
2. 우리는 기본으로 시작 Dockerfile하여 몇 가지 조정을 합니다.
3. 그런 다음 .NET 대신 빌드 플러그인(Maven 및 Gradle용)을 사용하는 몇 가지 옵션을 보여줍니다
4. docker은 "시작하기" 가이드이므로 범위는 몇 가지 기본 요구 사항으로 제한됩니다. 프로덕션용 컨테이너 이미지를 빌드하는 경우 고려해야 할 사항이 많고 짧은 가이드에서 모든 것을 다룰 수는 없습니다.

1.1. What You Will Build

• Docker 는 사용자가 컨테이너 이미지를 게시하고 다른 사람이 게시한 이미지를 사용(consume those published by others.)할 수 있도록 하는 "소셜" 측면이 있는 Linux 컨테이너 관리 도구(Linux container management toolkit)입니다.
• Docker 이미지는 컨테이너화된 프로세스를 실행하기 위한 레시피입니다. 이 가이드에서는 간단한 Spring 부트 애플리케이션용으로 빌드합니다.

1-2. What You Will Need

필요 시간

• About 15 minutes

필요 기술

• A favorite text editor or IDE
• JDK 1.8 or later
• Gradle 4+ or Maven 3.2+
• You can also import the code straight into your IDE:
  • Spring Tool Suite (STS)
  • IntelliJ IDEA

필요 작업

• Linux 시스템을 사용하지 않는 경우 가상화된 서버가 필요합니다. ㄴ 1. VirtualBox를 설치하면 Mac과 같은 다른 도구에서 boot2docker원활하게 관리할 수 있습니다. ㄴ 2. VirtualBox의 다운로드 사이트를 방문 하여 컴퓨터의 버전을 선택하십시오. 다운로드하여 설치합니다. ㄴ 3. 실제로 실행하는 것에 대해 걱정하지 마십시오.

• 64비트 머신에서만 실행되는 Docker 도 필요 합니다. ㄴ 1. 컴퓨터에 Docker를 설정하는 방법에 대한 자세한 내용은 https://docs.docker.com/installation/#installation 을 참조 하세요 . ㄴ 2. 계속 진행하기 전에 docker쉘에서 명령을 실행할 수 있는지 확인하십시오 . ㄴ 3. 프로세스를 사용하는 경우 먼저 boot2docker 실행해야 합니다

2. 서버

목차

• 서버 : Spring Boot Application
  • 2-1. 서버 구성 : Spring Initializr
  • 2-2. 서버 구현 : simple application > restAPI

2-1. 서버 구성

1. https://start.spring.io로 이동(Navigate to)합니다. 이 서비스는 애플리케이션에 필요한 모든 종속성(dependencies)을 가져오고 대부분의 설정을 자동으로 수행합니다.

2. Gradle 또는 Maven과 사용하려는 언어를 선택합니다. 이 가이드에서는 Java를 선택했다고 가정합니다.

3. 종속성(Dependencies)을 클릭 하고 Spring Web 을 선택하십시오.

4. 생성(Generate) 을 클릭 합니다.

5. 선택 사항으로 구성된(configured with your choices.) 웹 응용 프로그램의** 아카이브인** 결과 ZIP 파일을 다운로드합니다.

If your IDE has the Spring Initializr integration, you can complete this process from your IDE.

You can also fork the project from Github and open it in your IDE or other editor.

2-2. 서버 구현 > Rest API logic

Now you can create a simple application:

src/main/java/hello/Application.java

package hello;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class Application {

  @RequestMapping("/")
  public String home() {
    return "Hello Docker World";
  }

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

}

• 코드 설명 :

  • by Spring MVC to handle web requests. The class is flagged as a @SpringBootApplication and as a @RestController, meaning that it is ready for use

  • @RequestMapping maps_ /_ to the home() method, which sends a

  • Hello World response.

  • The main() method uses Spring Boot’s SpringApplication.run() method to launch an application.

3. 도커에 있는 애플리케이션 실행

• 목차
  3. 도커 내 애플리케이션 실행 : run the application In docker 3-1. Docker os로 실행 3-2. Docker container로 실행

3-1. by Docker os

• 실행 Now we can run the application without the Docker container (that is, in the host OS): 이제 Docker 컨테이너 없이(즉, 호스트 OS에서) 애플리케이션을 실행할 수 있습니다.

  • If you use Gradle, run the following command: ./gradlew build && java -jar build/libs/gs-spring-boot-docker-0.1.0.jar
  • If you use Maven, run the following command: ./mvnw package && java -jar target/gs-spring-boot-docker-0.1.0.jar

• 출력 Then go to localhost:8080 to see your “Hello Docker World” message.

3-2. by Docker container

• *step 3-2-1. 컨테이너화 ? *

  • Docker에는 이미지의 "계층"을 지정( layers specify )하는 데 사용 하는 간단한 "Dockerfile" 파일 형식이 있습니다.

  • Spring Boot 프로젝트에서 다음 Dockerfile을 생성합니다. > 아래 예제 1,2,3

    
    

• ** step 3-2-2. 컨테이너화를 위한 도커파일 생성 **

  • *1) 플러그인별, 기본 생성 *

    • If you use Gradle, you can run it with the following command: docker build --build-arg JAR_FILE=build/libs/\*.jar -t springio/gs-spring-boot-docker
    • If you use Maven, you can run it with the following command: docker build -t springio/gs-spring-boot-docker .

  • ** 2) ** 이 명령은 이미지를 빌드하고 로 태그를 지정(tags builds)합니다 springio/gs-spring-boot-docker.

  • Command Form

  FROM openjdk:8-jdk-alpine
  ARG JAR_FILE=target/*.jar
  COPY ${JAR_FILE} app.jar
  ENTRYPOINT ["java","-jar","/app.jar"]

  • Command Attr

  • FROM : 이 Dockerfile은 매우 간단하지만 Java와 JAR 파일만 있으면( just Java and a JAR file ) 아무 장식 없이 Spring Boot 앱을 실행하는 데 필요한 모든 것입니다
  • ARG : 빌드는 애플리케이션을 실행할 스프링 사용자와 스프링 그룹을 생성합니다.
  • COPY : 그런 다음 app.jar로 실행되는 **컨테이너에 COPY 프로젝트에 JAR 파일을 복사 합니다.
  • ENTRYPOINT : ENTRYPOINT Java 프로세스를 래핑하는 셸이 없도록 Dockerfile의 배열 형식을 사용합니다. Docker에 대한 주제 가이드 는 이 주제에 대해 더 자세히 설명합니다.

  To reduce Tomcat startup time, we used to add a system property pointing to /dev/urandom as a source of entropy. This is not necessary anymore with JDK 8 or later.

  사용자 권한으로 애플리케이션을 실행하면 일부 위험을 완화하는 데 도움이 됩니다(see, for example,: StackExchange의 스레드 참조 ). 따라서 중요한 개선 사항 Dockerfile은 루트가 아닌 사용자로 응용 프로그램을 실행하는 것입니다.

• ** step 3-2-3. 출력 확인 **

FROM openjdk:8-jdk-alpine
RUN addgroup -S spring && adduser -S spring -G spring
USER spring:spring
ARG JAR_FILE=target/*.jar
${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

-  ** 출력 확인 1) **
애플리케이션을 빌드하고 실행할 때 애플리케이션 시작 로그에서 **사용자 이름**을 볼 수 있습니다. 

docker build -t springio/gs-spring-boot-docker .
docker run -p 8080:8080 springio/gs-spring-boot-docker 

-  ** 출력 확인 2)**
started by첫 번째 INFO로그 항목 에 유의하십시오 .

:: Spring Boot ::        (v2.2.1.RELEASE)

2020-04-23 07:29:41.729  INFO 1 --- [main] hello.Application                        : Starting Application on b94c86e91cf9 with PID 1 (/app started by spring in /)
...

- ** 4) 리팩토리 가능성 및 필요성**
    ㄴ 1. 또한 Spring Boot fat JAR 파일에는 **종속성과 애플리케이션 리소스가 명확하게 분리**되어 있으며 이 사실을 사용하여 성능을 개선할 수 있습니다. 핵심은 컨테이너 파일 시스템에 레이어를 만드는 것입니다. 
    ㄴ 2. 레이어는 빌드 시와 런타임(대부분의 런타임에서) 모두에 캐시되므로 **가장 자주 변경되는 리소스**(일반적으로 애플리케이션 자체의 클래스 및 **정적 리소스 static resources**)가 **더 느리게 변경되는 리소스 다음 에 레이어되기**를 원합니다 .
    ㄴ 3. 따라서 Dockerfile의 약간 다른 구현(**static resources**)을 사용합니다.

<br/>


- ** step 3-2-4. 도커 디렉토리의 위치와 네이밍 설정 **

  > ```
FROM openjdk:8-jdk-alpine
RUN addgroup -S spring && adduser -S spring -G spring
USER spring:spring
ARG DEPENDENCY=target/dependency
COPY ${DEPENDENCY}/BOOT-INF/lib /app/lib
COPY ${DEPENDENCY}/META-INF /app/META-INF
COPY ${DEPENDENCY}/BOOT-INF/classes /app
ENTRYPOINT ["java","-cp","app:app/lib/*","hello.Application"]

• 1) ** 저장위치 지정 이 Dockerfile에는 DEPENDENCY지방 JAR의 압축을 푼 디렉토리를 가리키는 매개변수(pointing DEPENDENCY parameter**)가 있습니다.

  • 부가 설명 1.
    1. If we get that right, it already contains a BOOT-INF/lib directory with the dependency JARs in it, and a BOOT-INF/classes directory with the application classes in it.
    2. Notice that we use the application’s own main class: hello.Application. (This is faster than using the indirection provided by the fat JAR launcher.) 우리는 애플리케이션의 자체 메인 클래스를 사용합니다: . (이는 팻 JAR 런처에서 제공하는 간접 참조를 사용하는 것보다 빠릅니다.)

• To use the DEPENDENCY parameter with Gradle, run the following command: mkdir -p build/dependency && (cd build/dependency; jar -xf ../libs/*.jar)

• To use the DEPENDENCY parameter with Maven, run the following command: mkdir -p target/dependency && (cd target/dependency; jar -xf ../*.jar)

• 의존성 주의사항

1. Exploding the JAR file can result in the classpath order being different at runtime. A well-behaved and well-written application should not care about this, but you may see behavior changes if the dependencies are not carefully managed.
   2. If you use boot2docker, you need to run it first before you do anything with the Docker command line or with the build tools (it runs a daemon process that handles the work for you in a virtual machine).

• step 3-2-4. 디렉토리명을 일컫는 디렉토리 매개변수 지정

  • From a Gradle build, you need to add the explicit build arguments in the Docker command line: docker build --build-arg DEPENDENCY=build/dependency -t springio/gs-spring-boot-docker .
  • To build the image in Maven, you can use a simpler Docker command line: docker build -t springio/gs-spring-boot-docker .

  Of course, if you use only Gradle, you could change the Dockerfile to make the default value of DEPENDENCY match the location of the unpacked archive.

• ** step 3-2-5. 고도화 히스토리 **

  1. Docker 명령줄을 사용하여 빌드하는 대신 빌드 플러그인을 사용할 수 있습니다. ㄴ Spring Boot는 자체 빌드 플러그인을 사용하여 Maven 또는 Gradle에서 컨테이너 빌드를 지원합니다.
  2. Google 에는 Maven 및 Gradle 플러그인이 포함된 Jib 이라는 오픈 소스 도구도 있습니다. ㄴ 아마도 이 접근 방식에서 가장 흥미로운 점은 Dockerfile을 필요로 하지않습니다. docker build 에서 가져온 것과 동일한 표준 컨테이너 형식을 사용하여 이미지를 빌드할 수 있습니다 ㄴ 또한 도커가 설치되지 않은 환경에서도 작동할 수 있습니다(빌드 서버에서는 일반적이지 않음).

  By default, the images generated by the default buildpacks do not run your application as root. Check the configuration guide for Gradle or Maven for how to change the default settings.

• • 기본적으로 기본 빌드팩에서 생성된 이미지는 애플리케이션을 루트로 실행하지 않습니다.** 기본 설정을 변경하는 방법 은 Gradle 또는 Maven 의 구성 가이드를 확인하세요 .

4. 도커 이미지로 빌드

( Build a Docker Image with Gradle )

• step 4-1. Gradle로 Docker 이미지 빌드
  • You can build a tagged docker image with Gradle in one command: ./gradlew bootBuildImage --imageName=springio/gs-spring-boot-docker
  • Build a Docker Image with Maven 빠르게 시작하려면 다음을 변경하지 않고 Spring Boot 이미지 생성기를 실행할 수 있습니다 pom.xml( Dockerfile, 여전히 있는 경우 무시됨). ./mvnw spring-boot:build-image -Dspring-boot.build-image.imageName=springio/gs-spring-boot-docker

5. 도커 이미지 실행

5.1. by Docker OS

• To push to a Docker registry *, 1) you need to have *permission to push, which you do not have by default. Docker 레지스트리에 푸시하려면 기본적으로 없는 푸시 권한이 있어야 합니다. 2) Change the image prefix to your own Dockerhub ID and docker login to make sure you are authenticated before you run Docker. 이미지 접두사를 고유한 Dockerhub ID로 변경하고 docker loginDocker를 실행하기 전에 인증되었는지 확인하십시오.

  • *step 1 . 도커에 푸쉬 * 이미지 접두사를 고유한 Dockerhub ID로 변경하고 docker loginDocker를 실행하기 전에 인증되었는지 확인하십시오.
  1. docker push 예제는 실패합니다 (Dockerhub의 "springio" 조직에 속하지 않는 한).
  2. 그러나 자신의 도커 ID와 일치하도록 구성을 변경하면 성공해야 합니다. 그러면 새로운 태그가 지정되고 배포된 이미지가 생성됩니다.
  3. 로컬로 빌드된 도커 이미지를 실행하기 위해 도커에 등록하거나 아무 것도 게시할 필요가 없습니다.
  4. Docker로 빌드한 경우 (명령줄 또는 Spring Boot에서) 여전히 로컬로 태그가 지정된 이미지가 있으며 다음과 같이 실행할 수 있습니다.
  • 명령 $ docker run -p 8080:8080 -t springio/gs-spring-boot-docker
  • 출력

    Container memory limit unset. Configuring JVM for 1G container.
    Calculated JVM Memory Configuration: -XX:MaxDirectMemorySize=10M -XX:MaxMetaspaceSize=86381K -XX:ReservedCodeCacheSize=240M -Xss1M -Xmx450194K (Head Room: 0%, Loaded Class Count: 12837, Thread Count: 250, Total Memory: 1073741824)
    .... 
    2015-03-31 13:25:48.035  INFO 1 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
      2015-03-31 13:25:48.037  INFO 1 --- [           main] hello.Application                        : Started Application in 5.613 seconds (JVM running for 7.293)  

    The CF memory calculator is used at runtime to size the JVM to fit the container. CF 메모리 계산기는 런타임에 컨테이너에 맞게 JVM의 크기를 조정하는 데 사용됩니다.

• step 2. 출력 확인 :

  • step 2-1. 기본 출력 확인 : The application is then available on http://localhost:8080 (visit that and it says, “Hello Docker World”). 그런 다음 애플리케이션은 http://localhost:8080 에서 사용할 수 있습니다 (방문하면 "Hello Docker World"라고 표시됨).

  • ** step 2. 번외 출력 :**

  • boot2docker가 있는 Mac을 사용하는 경우, 일반적으로 시작 시 다음과 같이 표시됩니다 : Docker client to the Docker daemon, please set: export DOCKER_CERT_PATH=/Users/gturnquist/.boot2docker/certs/boot2docker-vm export DOCKER_TLS_VERIFY=1 export DOCKER_HOST=tcp://192.168.59.103:2376
  • 애플리케이션을 보려면 localhost 대신 DOCKER_HOST의 IP 주소를 방문해야 합니다. 이 경우 VM의 공개 IP인 https://192.168.59.103:8080을 방문해야 합니다 .

  • ** step 2-1. 실행 중일 때, 출력 예시**

    $ docker ps
    CONTAINER ID        IMAGE                                   COMMAND                  CREATED             STATUS              PORTS                    NAMES
    81c723d22865        springio/gs-spring-boot-docker:latest   "java -Djava.secur..."   34 seconds ago      Up 33 seconds       0.0.0.0:8080->8080/tcp   goofy_brown  ```

  • step 2-2. 컨테이너 ID로 종료 명령.

    docker stop goofy_brown 
    81c723d22865 

  • *step2-3. 컨테이너 삭제. * (/var/lib/docker작업이 끝나면 컨테이너를 삭제할 수도 있습니다. 파일 시스템 어딘가에 유지됨). docker rm goofy_brown

5-2. by Spring Profiles

• step 1. 프로파일 환경설정 및 프로파일로 실행 ** Spring 프로필로 새로 생성된 Docker 이미지를 실행하는 것은 **환경 변수를 Docker 실행 명령( prod프로필용)에 전달하는 것만큼 쉽습니다 .
  • You can do the same for the prod profile: docker run -e "SPRING_PROFILES_ACTIVE=prod" -p 8080:8080 -t springio/gs-spring-boot-docker
  • You can do the same for the dev profile: docker run -e "SPRING_PROFILES_ACTIVE=dev" -p 8080:8080 -t springio/gs-spring-boot-docker

6. 디버깅

• step 7-1. 도커에 있는 애플리케이션 디버깅 ( Debugging the Application in a Docker Container) ** 애플리케이션을 디버그하려면 **JPDA Transport를 사용할 수 있습니다 . 컨테이너를 원격 서버처럼 취급(remote server treat)합니다. ㄴ 이 기능을 활성화하려면 JAVA_OPTS변수 에 Java 에이전트 설정을 전달 하고 컨테이너 실행 중에 에이전트의 포트를 localhost에 매핑합니다. ㄴ Mac용 Docker를 사용하면 블랙 매직 사용 없이 IP로 컨테이너에 액세스할 수 없기 때문에 제한이 있습니다.(lack magic usage)
  • docker run -e "JAVA_TOOL_OPTIONS=-agentlib:jdwp=transport=dt_socket,address=5005,server=y,suspend=n" -p 8080:8080 -p 5005:5005 -t springio/gs-spring-boot-docker

7. Summary

Congratulations!

• You have created a Docker container for a Spring Boot application!
• By default, Spring Boot 애플리케이션은 컨테이너 내부의 포트 8080에서 실행되며
• -p명령줄에서 를 사용하여 호스트의 동일한 포트에 매핑했습니다 .

See Also

다음 가이드도 도움이 될 수 있습니다.

• Spring MVC로 웹 콘텐츠 제공

• 스프링 부트로 애플리케이션 빌드

• Docker를 사용한 Spring Boot에 대한 주제 가이드 (이 가이드보다 더 깊이 있음)

1. 이 가이드는 Spring Boot 애플리케이션을 실행하기 위한** Docker 이미지를 빌드**하는 프로세스를 안내 합니다.
2. 우리는 기본으로 시작 Dockerfile하여 몇 가지 조정을 합니다.
3. 그런 다음 .NET 대신 빌드 플러그인(Maven 및 Gradle용)을 사용하는 몇 가지 옵션을 보여줍니다
4. docker은 "시작하기" 가이드이므로 범위는 몇 가지 기본 요구 사항으로 제한됩니다. 프로덕션용 컨테이너 이미지를 빌드하는 경우 고려해야 할 사항이 많고 짧은 가이드에서 모든 것을 다룰 수는 없습니다.

1. What You Will Build

• Docker 는 사용자가 컨테이너 이미지를 게시하고 다른 사람이 게시한 이미지를 사용(consume those published by others.)할 수 있도록 하는 "소셜" 측면이 있는 Linux 컨테이너 관리 도구(Linux container management toolkit)입니다.
• Docker 이미지는 컨테이너화된 프로세스를 실행하기 위한 레시피입니다. 이 가이드에서는 간단한 Spring 부트 애플리케이션용으로 빌드합니다.

2. What You Will Need

필요 시간

• About 15 minutes

필요 기술

• A favorite text editor or IDE
• JDK 1.8 or later
• Gradle 4+ or Maven 3.2+
• You can also import the code straight into your IDE:
  • Spring Tool Suite (STS)
  • IntelliJ IDEA

필요 작업

• Linux 시스템을 사용하지 않는 경우 가상화된 서버가 필요합니다. ㄴ 1. VirtualBox를 설치하면 Mac과 같은 다른 도구에서 boot2docker원활하게 관리할 수 있습니다. ㄴ 2. VirtualBox의 다운로드 사이트를 방문 하여 컴퓨터의 버전을 선택하십시오. 다운로드하여 설치합니다. ㄴ 3. 실제로 실행하는 것에 대해 걱정하지 마십시오.

• 64비트 머신에서만 실행되는 Docker 도 필요 합니다. ㄴ 1. 컴퓨터에 Docker를 설정하는 방법에 대한 자세한 내용은 https://docs.docker.com/installation/#installation 을 참조 하세요 . ㄴ 2. 계속 진행하기 전에 docker쉘에서 명령을 실행할 수 있는지 확인하십시오 . ㄴ 3. 프로세스를 사용하는 경우 먼저 boot2docker 실행해야 합니다

3. Starting with Spring Initializr

프로젝트를 초기화하려면:

1. https://start.spring.io로 이동(Navigate to)합니다. 이 서비스는 애플리케이션에 필요한 모든 종속성(dependencies)을 가져오고 대부분의 설정을 자동으로 수행합니다.

2. Gradle 또는 Maven과 사용하려는 언어를 선택합니다. 이 가이드에서는 Java를 선택했다고 가정합니다.

3. 종속성(Dependencies)을 클릭 하고 Spring Web 을 선택하십시오.

4. 생성(Generate) 을 클릭 합니다.

5. 선택 사항으로 구성된(configured with your choices.) 웹 응용 프로그램의** 아카이브인** 결과 ZIP 파일을 다운로드합니다.

If your IDE has the Spring Initializr integration, you can complete this process from your IDE.

You can also fork the project from Github and open it in your IDE or other editor.

4. Set up a Spring Boot Application

4.1. simple application

Now you can create a simple application:

src/main/java/hello/Application.java

package hello;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class Application {

  @RequestMapping("/")
  public String home() {
    return "Hello Docker World";
  }

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

}

• 코드 설명 :

  • by Spring MVC to handle web requests. The class is flagged as a @SpringBootApplication and as a @RestController, meaning that it is ready for use

  • @RequestMapping maps_ /_ to the home() method, which sends a

  • Hello World response.

  • The main() method uses Spring Boot’s SpringApplication.run() method to launch an application.

4.2. run the application

• 실행 Now we can run the application without the Docker container (that is, in the host OS): 이제 Docker 컨테이너 없이(즉, 호스트 OS에서) 애플리케이션을 실행할 수 있습니다.

  • If you use Gradle, run the following command: ./gradlew build && java -jar build/libs/gs-spring-boot-docker-0.1.0.jar
  • If you use Maven, run the following command: ./mvnw package && java -jar target/gs-spring-boot-docker-0.1.0.jar

• 출력 Then go to localhost:8080 to see your “Hello Docker World” message.

5. Containerize It (컨테이너화)

• 컨테이너화

  • Docker에는 이미지의 "계층"을 지정( layers specify )하는 데 사용 하는 간단한 "Dockerfile" 파일 형식이 있습니다.
  • Spring Boot 프로젝트에서 다음 Dockerfile을 생성합니다.
  
  

Example 1. Dockerfile

• Command Form

FROM openjdk:8-jdk-alpine
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

• 속성 ```

• 1. FROM : ㄴ 이 Dockerfile은 매우 간단하지만 Java와 JAR 파일만 있으면( just Java and a JAR file ) 아무 장식 없이 Spring Boot 앱을 실행하는 데 필요한 모든 것입니다
• 2. ARG : ㄴ 빌드는 애플리케이션을 실행할 스프링 사용자와 스프링 그룹을 생성합니다.
• 3. COPY : ㄴ 그런 다음 app.jar로 실행되는 **컨테이너에 COPY 프로젝트에 JAR 파일을 복사 합니다.
• 4. ENTRYPOINT : ㄴ ENTRYPOINT Java 프로세스를 래핑하는 셸이 없도록 Dockerfile의 배열 형식을 사용합니다. Docker에 대한 주제 가이드 는 이 주제에 대해 더 자세히 설명합니다.

• ** step1-1. 플러그인별 컨테이너화 명령**

  • If you use Gradle, you can run it with the following command: docker build --build-arg JAR_FILE=build/libs/\*.jar -t springio/gs-spring-boot-docker
  • If you use Maven, you can run it with the following command: docker build -t springio/gs-spring-boot-docker .

• step1-2. 이 명령은 이미지를 빌드하고 로 태그를 지정(tags builds)합니다 springio/gs-spring-boot-docker.

To reduce Tomcat startup time, we used to add a system property pointing to /dev/urandom as a source of entropy. This is not necessary anymore with JDK 8 or later.

사용자 권한으로 애플리케이션을 실행하면 일부 위험을 완화하는 데 도움이 됩니다(see, for example,: StackExchange의 스레드 참조 ). 따라서 중요한 개선 사항 Dockerfile은 루트가 아닌 사용자로 응용 프로그램을 실행하는 것입니다.

Example 2. Dockerfile

FROM openjdk:8-jdk-alpine
RUN addgroup -S spring && adduser -S spring -G spring
USER spring:spring
ARG JAR_FILE=target/*.jar
${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

-  ** step 2-1-1. 출력 확인 **
애플리케이션을 빌드하고 실행할 때 애플리케이션 시작 로그에서 **사용자 이름**을 볼 수 있습니다. 

docker build -t springio/gs-spring-boot-docker .
docker run -p 8080:8080 springio/gs-spring-boot-docker 

-  ** step 2-1-2. 출력 확인 **
started by첫 번째 INFO로그 항목 에 유의하십시오 .

:: Spring Boot ::        (v2.2.1.RELEASE)

2020-04-23 07:29:41.729  INFO 1 --- [main] hello.Application                        : Starting Application on b94c86e91cf9 with PID 1 (/app started by spring in /)
...

- **리팩토리 가능성 및 필요성**
    ㄴ 1. 또한 Spring Boot fat JAR 파일에는 **종속성과 애플리케이션 리소스가 명확하게 분리**되어 있으며 이 사실을 사용하여 성능을 개선할 수 있습니다. 핵심은 컨테이너 파일 시스템에 레이어를 만드는 것입니다. 
    ㄴ 2. 레이어는 빌드 시와 런타임(대부분의 런타임에서) 모두에 캐시되므로 **가장 자주 변경되는 리소스**(일반적으로 애플리케이션 자체의 클래스 및 **정적 리소스 static resources**)가 **더 느리게 변경되는 리소스 다음 에 레이어되기**를 원합니다 .
    ㄴ 3. 따라서 Dockerfile의 약간 다른 구현(**static resources**)을 사용합니다.

<br/>


### Example 3. Dockerfile

> ```
FROM openjdk:8-jdk-alpine
RUN addgroup -S spring && adduser -S spring -G spring
USER spring:spring
ARG DEPENDENCY=target/dependency
COPY ${DEPENDENCY}/BOOT-INF/lib /app/lib
COPY ${DEPENDENCY}/META-INF /app/META-INF
COPY ${DEPENDENCY}/BOOT-INF/classes /app
ENTRYPOINT ["java","-cp","app:app/lib/*","hello.Application"]

• step 3-1. 저장위치 지정 이 Dockerfile에는 DEPENDENCY지방 JAR의 압축을 푼 디렉토리를 가리키는 매개변수(pointing DEPENDENCY parameter)가 있습니다.

  • 부가 설명 1.
    1. If we get that right, it already contains a BOOT-INF/lib directory with the dependency JARs in it, and a BOOT-INF/classes directory with the application classes in it.
    2. Notice that we use the application’s own main class: hello.Application. (This is faster than using the indirection provided by the fat JAR launcher.) 우리는 애플리케이션의 자체 메인 클래스를 사용합니다: . (이는 팻 JAR 런처에서 제공하는 간접 참조를 사용하는 것보다 빠릅니다.)

  • To use the DEPENDENCY parameter with Gradle, run the following command: mkdir -p build/dependency && (cd build/dependency; jar -xf ../libs/*.jar)
  • To use the DEPENDENCY parameter with Maven, run the following command: mkdir -p target/dependency && (cd target/dependency; jar -xf ../*.jar)

• 의존성 주의사항
  1. Exploding the JAR file can result in the classpath order being different at runtime. A well-behaved and well-written application should not care about this, but you may see behavior changes if the dependencies are not carefully managed.
  2. If you use boot2docker, you need to run it first before you do anything with the Docker command line or with the build tools (it runs a daemon process that handles the work for you in a virtual machine).

• step 3-2. 디렉토리 매개변수 지정
  • From a Gradle build, you need to add the explicit build arguments in the Docker command line: docker build --build-arg DEPENDENCY=build/dependency -t springio/gs-spring-boot-docker .
  • To build the image in Maven, you can use a simpler Docker command line: docker build -t springio/gs-spring-boot-docker .

Of course, if you use only Gradle, you could change the Dockerfile to make the default value of DEPENDENCY match the location of the unpacked archive.

• Docker 명령줄을 사용하여 빌드하는 대신 빌드 플러그인을 사용할 수 있습니다. ㄴ Spring Boot는 자체 빌드 플러그인을 사용하여 Maven 또는 Gradle에서 컨테이너 빌드를 지원합니다.
• Google 에는 Maven 및 Gradle 플러그인이 포함된 Jib 이라는 오픈 소스 도구도 있습니다. ㄴ 아마도 이 접근 방식에서 가장 흥미로운 점은 Dockerfile을 필요로 하지않습니다. docker build 에서 가져온 것과 동일한 표준 컨테이너 형식을 사용하여 이미지를 빌드할 수 있습니다 ㄴ 또한 도커가 설치되지 않은 환경에서도 작동할 수 있습니다(빌드 서버에서는 일반적이지 않음).

By default, the images generated by the default buildpacks do not run your application as root. Check the configuration guide for Gradle or Maven for how to change the default settings. ** 기본적으로 기본 빌드팩에서 생성된 이미지는 애플리케이션을 루트로 실행하지 않습니다.** 기본 설정을 변경하는 방법 은 Gradle 또는 Maven 의 구성 가이드를 확인하세요 .

6. Build a Docker Image with Gradle

• step 6-1. Gradle로 Docker 이미지 빌드
  • You can build a tagged docker image with Gradle in one command: ./gradlew bootBuildImage --imageName=springio/gs-spring-boot-docker
  • Build a Docker Image with Maven 빠르게 시작하려면 다음을 변경하지 않고 Spring Boot 이미지 생성기를 실행할 수 있습니다 pom.xml( Dockerfile, 여전히 있는 경우 무시됨). ./mvnw spring-boot:build-image -Dspring-boot.build-image.imageName=springio/gs-spring-boot-docker

• step 6-2. To push to a Docker registry, ㄴ you need to have permission to push, which you do not have by default. Docker 레지스트리에 푸시하려면 기본적으로 없는 푸시 권한이 있어야 합니다. ㄴ. Change the image prefix to your own Dockerhub ID and docker login to make sure you are authenticated before you run Docker. 이미지 접두사를 고유한 Dockerhub ID로 변경하고 docker loginDocker를 실행하기 전에 인증되었는지 확인하십시오.

7. After the Push

• *step 7-1. 도커 푸쉬 * 이미지 접두사를 고유한 Dockerhub ID로 변경하고 docker loginDocker를 실행하기 전에 인증되었는지 확인하십시오.
  1. docker push 예제는 실패합니다 (Dockerhub의 "springio" 조직에 속하지 않는 한).
  2. 그러나 자신의 도커 ID와 일치하도록 구성을 변경하면 성공해야 합니다. 그러면 새로운 태그가 지정되고 배포된 이미지가 생성됩니다.
  3. 로컬로 빌드된 도커 이미지를 실행하기 위해 도커에 등록하거나 아무 것도 게시할 필요가 없습니다.
  4. Docker로 빌드한 경우 (명령줄 또는 Spring Boot에서) 여전히 로컬로 태그가 지정된 이미지가 있으며 다음과 같이 실행할 수 있습니다.

       $ docker run -p 8080:8080 -t springio/gs-spring-boot-docker
       Container memory limit unset. Configuring JVM for 1G container.
       Calculated JVM Memory Configuration: -XX:MaxDirectMemorySize=10M -XX:MaxMetaspaceSize=86381K -XX:ReservedCodeCacheSize=240M -Xss1M -Xmx450194K (Head Room: 0%, Loaded Class Count: 12837, Thread Count: 250, Total Memory: 1073741824)
       ....
       2015-03-31 13:25:48.035  INFO 1 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
       2015-03-31 13:25:48.037  INFO 1 --- [           main] hello.Application                        : Started Application in 5.613 seconds (JVM running for 7.293)

The CF memory calculator is used at runtime to size the JVM to fit the container. CF 메모리 계산기는 런타임에 컨테이너에 맞게 JVM의 크기를 조정하는 데 사용됩니다.

• step 7-1. 출력 확인 : The application is then available on http://localhost:8080 (visit that and it says, “Hello Docker World”). 그런 다음 애플리케이션은 http://localhost:8080 에서 사용할 수 있습니다 (방문하면 "Hello Docker World"라고 표시됨).

• boot2docker가 있는 Mac을 사용하는 경우 > 출력 예시.
  boot2docker가 있는 Mac을 사용하는 경우, 일반적으로 시작 시 다음과 같이 표시됩니다 :

Docker client to the Docker daemon, please set:
    export DOCKER_CERT_PATH=/Users/gturnquist/.boot2docker/certs/boot2docker-vm
    export DOCKER_TLS_VERIFY=1
    export DOCKER_HOST=tcp://192.168.59.103:2376

애플리케이션을 보려면 localhost 대신 DOCKER_HOST의 IP 주소를 방문해야 합니다. 이 경우 VM의 공개 IP인 https://192.168.59.103:8080을 방문해야 합니다 .

• ** 실행 중일 때, 출력 예시**

  $ docker ps
  CONTAINER ID        IMAGE                                   COMMAND                  CREATED             STATUS              PORTS                    NAMES
  81c723d22865        springio/gs-spring-boot-docker:latest   "java -Djava.secur..."   34 seconds ago      Up 33 seconds       0.0.0.0:8080->8080/tcp   goofy_brown  ```

• 컨테이너 ID로 종료 명령.

  docker stop goofy_brown 
  81c723d22865 

• *컨테이너 삭제. * (/var/lib/docker작업이 끝나면 컨테이너를 삭제할 수도 있습니다. 파일 시스템 어딘가에 유지됨). docker rm goofy_brown

8. Using Spring Profiles

• step 8-1. 프로파일 환경설정 및 프로파일로 실행 ** Spring 프로필로 새로 생성된 Docker 이미지를 실행하는 것은 **환경 변수를 Docker 실행 명령( prod프로필용)에 전달하는 것만큼 쉽습니다 .
  • You can do the same for the prod profile: docker run -e "SPRING_PROFILES_ACTIVE=prod" -p 8080:8080 -t springio/gs-spring-boot-docker
  • You can do the same for the dev profile: docker run -e "SPRING_PROFILES_ACTIVE=dev" -p 8080:8080 -t springio/gs-spring-boot-docker

9. Debugging the Application in a Docker Container

• 디버깅 애플리케이션을 디버그하려면 JPDA Transport를 사용할 수 있습니다 . 컨테이너를 원격 서버처럼 취급(remote server treat)합니다. ㄴ 이 기능을 활성화하려면 JAVA_OPTS변수 에 Java 에이전트 설정을 전달 하고 컨테이너 실행 중에 에이전트의 포트를 localhost에 매핑합니다. ㄴ Mac용 Docker를 사용하면 블랙 매직 사용 없이 IP로 컨테이너에 액세스할 수 없기 때문에 제한이 있습니다.(lack magic usage)
  • docker run -e "JAVA_TOOL_OPTIONS=-agentlib:jdwp=transport=dt_socket,address=5005,server=y,suspend=n" -p 8080:8080 -p 5005:5005 -t springio/gs-spring-boot-docker

10. Summary

Congratulations!

• You have created a Docker container for a Spring Boot application!
• By default, Spring Boot 애플리케이션은 컨테이너 내부의 포트 8080에서 실행되며
• -p명령줄에서 를 사용하여 호스트의 동일한 포트에 매핑했습니다 .

See Also

다음 가이드도 도움이 될 수 있습니다.

• Spring MVC로 웹 콘텐츠 제공

• 스프링 부트로 애플리케이션 빌드

• Docker를 사용한 Spring Boot에 대한 주제 가이드 (이 가이드보다 더 깊이 있음)

There is also a Topical Guide on Docker, which covers a wider range of choices that we have here and in much more detail.

1. What You Will Build Docker is a Linux container management toolkit with a “social” aspect, letting users publish container images and consume those published by others. A Docker image is a recipe for running a containerized process. In this guide, we build one for a simple Spring boot application.

2. What You Will Need 필요 시간

About 15 minutes 필요 기술

A favorite text editor or IDE JDK 1.8 or later Gradle 4+ or Maven 3.2+ You can also import the code straight into your IDE:

• Spring Tool Suite (STS)
• IntelliJ IDEA If you are NOT using a Linux machine, you need a virtualized server. If you install VirtualBox, other tools like the Mac’s boot2docker can seamlessly manage it for you. Visit VirtualBox’s download site and pick the version for your machine. Download and install. Do not worry about actually running it.

You also need Docker, which only runs on 64-bit machines. See https://docs.docker.com/installation/#installation for details on setting Docker up for your machine. Before proceeding further, verify you can run docker commands from the shell. If you use boot2docker, you need to run that first.

3. Starting with Spring Initializr To initialize the project:

Navigate to https://start.spring.io. This service pulls in all the dependencies you need for an application and does most of the setup for you.

Choose either Gradle or Maven and the language you want to use. This guide assumes that you chose Java.

Click Dependencies and select Spring Web.

Click Generate.

Download the resulting ZIP file, which is an archive of a web application that is configured with your choices.

If your IDE has the Spring Initializr integration, you can complete this process from your IDE.

You can also fork the project from Github and open it in your IDE or other editor.

4. Set up a Spring Boot Application Now you can create a simple application:

src/main/java/hello/Application.java

package hello;

import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication @RestController public class Application {

@RequestMapping("/") public String home() { return "Hello Docker World"; }

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

} The class is flagged as a @SpringBootApplication and as a @RestController, meaning that it is ready for use by Spring MVC to handle web requests. @RequestMapping maps / to the home() method, which sends a Hello World response. The main() method uses Spring Boot’s SpringApplication.run() method to launch an application.

Now we can run the application without the Docker container (that is, in the host OS):

If you use Gradle, run the following command:

./gradlew build && java -jar build/libs/gs-spring-boot-docker-0.1.0.jar If you use Maven, run the following command:

./mvnw package && java -jar target/gs-spring-boot-docker-0.1.0.jar Then go to localhost:8080 to see your “Hello Docker World” message.

5. Containerize It Docker has a simple "Dockerfile" file format that it uses to specify the “layers” of an image. Create the following Dockerfile in your Spring Boot project:

Example 1. Dockerfile FROM openjdk:8-jdk-alpine ARG JAR_FILE=target/*.jar COPY ${JAR_FILE} app.jar ENTRYPOINT ["java","-jar","/app.jar"] If you use Gradle, you can run it with the following command:

docker build --build-arg JAR_FILE=build/libs/*.jar -t springio/gs-spring-boot-docker If you use Maven, you can run it with the following command:

docker build -t springio/gs-spring-boot-docker . This command builds an image and tags it as

springio/gs-spring-boot-docker. This Dockerfile is very simple, but it is all you need to run a Spring Boot app with no frills: just Java and a JAR file. The build creates a spring user and a spring group to run the application. It is then copied (by the COPY command) the project JAR file into the container as app.jar, which is run in the ENTRYPOINT. The array form of the Dockerfile ENTRYPOINT is used so that there is no shell wrapping the Java process. The Topical Guide on Docker goes into this topic in more detail.

To reduce Tomcat startup time, we used to add a system property pointing to /dev/urandom as a source of entropy. This is not necessary anymore with JDK 8 or later.

Running applications with user privileges helps to mitigate some risks (see, for example, a thread on StackExchange). So, an important improvement to the Dockerfile is to run the application as a non-root user:

Example 2. Dockerfile FROM openjdk:8-jdk-alpine RUN addgroup -S spring && adduser -S spring -G spring USER spring:spring ARG JAR_FILE=target/*.jar ${JAR_FILE} app.jar ENTRYPOINT ["java","-jar","/app.jar"] You can see the username in the application startup logs when you build and run the application:

docker build -t springio/gs-spring-boot-docker . docker run -p 8080:8080 springio/gs-spring-boot-docker Note the started by in the first INFO log entry:

:: Spring Boot :: (v2.2.1.RELEASE)

2020-04-23 07:29:41.729 INFO 1 --- [ main] hello.Application : Starting Application on b94c86e91cf9 with PID 1 (/app started by spring in /) ... Also, there is a clean separation between dependencies and application resources in a Spring Boot fat JAR file, and we can use that fact to improve performance. The key is to create layers in the container filesystem. The layers are cached both at build time and at runtime (in most runtimes), so we want the most frequently changing resources (usually the class and static resources in the application itself) to be layered after the more slowly changing resources. Thus, we use a slightly different implementation of the Dockerfile:

Example 3. Dockerfile FROM openjdk:8-jdk-alpine RUN addgroup -S spring && adduser -S spring -G spring USER spring:spring ARG DEPENDENCY=target/dependency COPY ${DEPENDENCY}/BOOT-INF/lib /app/lib COPY ${DEPENDENCY}/META-INF /app/META-INF COPY ${DEPENDENCY}/BOOT-INF/classes /app ENTRYPOINT ["java","-cp","app:app/lib/*","hello.Application"] This Dockerfile has a DEPENDENCY parameter pointing to a directory where we have unpacked the fat JAR. To use the DEPENDENCY parameter with Gradle, run the following command:

mkdir -p build/dependency && (cd build/dependency; jar -xf ../libs/*.jar) To use the DEPENDENCY parameter with Maven, run the following command:

mkdir -p target/dependency && (cd target/dependency; jar -xf ../*.jar) If we get that right, it already contains a BOOT-INF/lib directory with the dependency JARs in it, and a BOOT-INF/classes directory with the application classes in it. Notice that we use the application’s own main class: hello.Application. (This is faster than using the indirection provided by the fat JAR launcher.)

Exploding the JAR file can result in the classpath order being different at runtime. A well-behaved and well-written application should not care about this, but you may see behavior changes if the dependencies are not carefully managed.

If you use boot2docker, you need to run it first before you do anything with the Docker command line or with the build tools (it runs a daemon process that handles the work for you in a virtual machine).

From a Gradle build, you need to add the explicit build arguments in the Docker command line:

docker build --build-arg DEPENDENCY=build/dependency -t springio/gs-spring-boot-docker . To build the image in Maven, you can use a simpler Docker command line:

docker build -t springio/gs-spring-boot-docker . Of course, if you use only Gradle, you could change the Dockerfile to make the default value of DEPENDENCY match the location of the unpacked archive.

Instead of building with the Docker command line, you might want to use a build plugin. Spring Boot supports building a container from Maven or Gradle by using its own build plugin. Google also has an open source tool called Jib that has Maven and Gradle plugins. Probably the most interesting thing about this approach is that you do not need a Dockerfile. You can build the image by using the same standard container format as you get from docker build. Also, it can work in environments where docker is not installed (not uncommon in build servers).

By default, the images generated by the default buildpacks do not run your application as root. Check the configuration guide for Gradle or Maven for how to change the default settings.

6. Build a Docker Image with Gradle You can build a tagged docker image with Gradle in one command:

./gradlew bootBuildImage --imageName=springio/gs-spring-boot-docker 6.1. Build a Docker Image with Maven To get started quickly, you can run the Spring Boot image generator without even changing your pom.xml (remember that the Dockerfile, if it is still, there is ignored):

./mvnw spring-boot:build-image -Dspring-boot.build-image.imageName=springio/gs-spring-boot-docker To push to a Docker registry, you need to have permission to push, which you do not have by default. Change the image prefix to your own Dockerhub ID and docker login to make sure you are authenticated before you run Docker.

7. After the Push A docker push in the example fails (unless you are part of the "springio" organization at Dockerhub). However, if you change the configuration to match your own docker ID, it should succeed. You then have a new tagged, deployed image.

You do NOT have to register with docker or publish anything to run a docker image that was built locally. If you built with Docker (from the command line or from Spring Boot), you still have a locally tagged image, and you can run it like this:

$ docker run -p 8080:8080 -t springio/gs-spring-boot-docker Container memory limit unset. Configuring JVM for 1G container. Calculated JVM Memory Configuration: -XX:MaxDirectMemorySize=10M -XX:MaxMetaspaceSize=86381K -XX:ReservedCodeCacheSize=240M -Xss1M -Xmx450194K (Head Room: 0%, Loaded Class Count: 12837, Thread Count: 250, Total Memory: 1073741824) .... 2015-03-31 13:25:48.035 INFO 1 --- [ main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http) 2015-03-31 13:25:48.037 INFO 1 --- [ main] hello.Application : Started Application in 5.613 seconds (JVM running for 7.293) The CF memory calculator is used at runtime to size the JVM to fit the container.

The application is then available on http://localhost:8080 (visit that and it says, “Hello Docker World”).

When using a Mac with boot2docker, you typically see things like this at startup:

Docker client to the Docker daemon, please set: export DOCKER_CERT_PATH=/Users/gturnquist/.boot2docker/certs/boot2docker-vm export DOCKER_TLS_VERIFY=1 export DOCKER_HOST=tcp://192.168.59.103:2376 To see the application, you must visit the IP address in DOCKER_HOST instead of localhost — in this case, https://192.168.59.103:8080, the public facing IP of the VM.

When it is running, you can see in the list of containers, similar to the following example:

$ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 81c723d22865 springio/gs-spring-boot-docker:latest "java -Djava.secur..." 34 seconds ago Up 33 seconds 0.0.0.0:8080->8080/tcp goofy_brownCOPY To shut it down again, you can run docker stop with the container ID from the previous listing (yours will be different):

docker stop goofy_brown 81c723d22865COPY If you like, you can also delete the container (it is persisted in your filesystem somewhere under /var/lib/docker) when you are finished with it:

docker rm goofy_brownCOPY

8. Using Spring Profiles Running your freshly minted Docker image with Spring profiles is as easy as passing an environment variable to the Docker run command (for the prod profile):

docker run -e "SPRING_PROFILES_ACTIVE=prod" -p 8080:8080 -t springio/gs-spring-boot-docker You can do the same for the dev profile:

docker run -e "SPRING_PROFILES_ACTIVE=dev" -p 8080:8080 -t springio/gs-spring-boot-docker 9. Debugging the Application in a Docker Container To debug the application, you can use JPDA Transport. We treat the container like a remote server. To enable this feature, pass Java agent settings in the JAVA_OPTS variable and map the agent’s port to localhost during a container run. With Docker for Mac, there is a limitation because we can’t access the container by IP without black magic usage.

docker run -e "JAVA_TOOL_OPTIONS=-agentlib:jdwp=transport=dt_socket,address=5005,server=y,suspend=n" -p 8080:8080 -p 5005:5005 -t springio/gs-spring-boot-docker 10. Summary Congratulations! You have created a Docker container for a Spring Boot application! By default, Spring Boot applications run on port 8080 inside the container, and we mapped that to the same port on the host by using -p on the command line.

See Also The following guides may also be helpful:

Serving Web Content with Spring MVC

Building an Application with Spring Boot

Topical Guide on Spring Boot with Docker (more depth than this guide)

Want to write a new guide or contribute to an existing one? Check out our contribution guidelines.

(Done) 교보생명 어드민 봇 관련 문의 대응 ( w 루카스 ) - 1h ㄴ 어플리케이션 접근 > vpn 락 확인 ㄴ 깃 구동 > 그레들 오류 확인 ㄴ 담당자확인 및 내용 전달

1.1. 라이브러리와 maven/ gradle

gradle : 다운로드와 라이브러리 종속성 관리를 위한 도입 https://linkeverything.github.io/study/springboot/add-library/

gradle : 멀티프로젝트를 위한 도입 https://engineering.linecorp.com/ko/blog/mono-repo-multi-project-gradle-plugin/

1.2. gradle 사용자 라이브러리 추가

Spring + gradle 사용시 Tibero 같이 repo에 없는 라이브러리들이 필요한 경우나 폐쇄망에선 다음과같이 라이브러리를 추가한다

1. 프로젝트 폴더 최상단에 libs 폴더 생성(이름은 마음대로)

2. 폴더에 라이브러리 복사

3. build.gradle - dependencies 블럭에 다음과 같은 코드를 추가한다.

dependencies {
compile files("libs/tibero6-jdbc-14.jar") }

4. Refresh Gradle Project 출처 : https://sy-dev.tistory.com/28

1.3. 라이브러리 clean

• 현상 : jsp 라이브러리 gradle에 추가 > refresh하여 등록 > jsp샘플 페이지 생성 > 웹브라우저에 webapp하위 jsp 경로인 rootDoc URL 호출. > jsp페이지 호출이 아닌 다운로드가 됨.
• 문제(원인) : 라이브러리의 정상 등록이 안됨. out.write("abc") 메소드의 빨간줄로 확인
• 해결 : 라이브러리 캐시 clean https://countryxide.tistory.com/155

기술문서 구독

1. HTTP 어플리케이션 https://kscodebase.tistory.com/category/programming/HTTP

• http 통신 != socket 통신 https://pearlluck.tistory.com/335

2. socket 어플리케이션 https://medium.com/@chullino/http%EC%97%90%EC%84%9C%EB%B6%80%ED%84%B0-websocket%EA%B9%8C%EC%A7%80-94df91988788

2020.09.14

• git 클라이언트 ' fork ' 도입
• 포트폴리오용 jira 도입 보류 ( 원리를 몰겟슘 )

• 메이븐
• 그레들

LANGUAGE

• 자바
• 코틀린
• 그루비

PRJ MetaData Group Artifact Package Name

Packaging ( 둘다 내장서버 포함 가능 )

• jar
• war : JSP 구동 제공하기때문에 was, 톰캣서버 별도 설치가능 제공.

• 프로젝트 정상 실행 테스트 spring boot 다운 / 톰캣 구동 / localhost:8080 white errror 페이지 정상확인

white errror 페이지가 없어 에러페이지를 정상적으로 포워딩 시켜준거임 ( 정상)

개요2 - 서버에서 어떻게 구현할꺼야 ? 결국 서블릿은 , HTTP 요청을 어떻게 받고, HTTP 응답을 어떻게 내려줄거야?를 개발자가 서버에서 어떻게 편하게 구현할까에 대한것.

어떻게 사용하는지, 어떻게 해결하면 되는지.

• 시스템 목적을 달성하기위해 시스템의 상호작용등의 시스템디자인에 대한 제약 및 설계이다
• 산출물 > 시스템 구성도 https://tuhbm.github.io/2019/04/24/architecture/

아키텍처를 다루는 사람들

• R&R > 나중에 시스템 구성도별 R&R 분리해보기. https://thinkground.studio/%EC%95%84%ED%82%A4%ED%85%8D%ED%8A%B8-architecture%EB%A5%BC-%EB%8B%A4%EB%A3%A8%EB%8A%94-%EC%82%AC%EB%9E%8C/

1. 구현

1-1 문서 외부 이동 (앵커 활용)

1-2 문서 내부 이동 (앵커 활용)

1-3 버튼 UI 이동

1-4 DIV 이동

1-5 Link 이동

2. 추가 (살 붙이기 )

2-1 해당 위치로 이동 ( CSS로 구현 )

이 문제를 해결하기 위해서 스크립트를 사용하지 않고 CSS 스타일만으로 해결되는 간단한 방법이 없을지 여러 방법들을 테스트하다가 아래와 같이 코드를 작성하였다. 출처 : 동일 페이지에서 링크로 섹션 이동시 고정 헤더에 가리는 문제

3. 앵커 <a>

3-1 속성

3-2. 주소 체계

3-2-1 상대 주소

3-2-2 절대 주소

4. 참고

참고1. 웹 프로그래밍 - 링크와 프레임(<iframe>)

참고2. HTML A 태그

참고3. 페이지(문서) 또는 다른 페이지의 특정 위치로 이동하기

SaaS 앱을 개발하기 위한 방법론

1. 특징

• 설정 자동화를 위한 절차 체계화로 새로운 개발자가 프로젝트에 참여하는데 드는 시간과 비용을 최소화
• OS에 따라 달라지는 부분을 명확히하고, 실행 환경 사이의 이식성을 극대화
• 최근 등장한 클라우드 플랫폼 배포에 적합하고, 서버와 시스템의 관리가 불필요
• 개발 환경과 운영 환경의 차이를 최소화하고 민첩성을 극대화하기 위해 지속적인 배포 가능
• 툴, 아키텍처, 개발 방식을 크게 바꾸지 않고 확장(scale up) 가능

2. 12개의 요소

5-4 철저하게 분리된 빌드와 실행단계

> 5-4-2 컴파일(Compile)

컴파일이란 개발자가 작성한 소스코드를 바이너리 코드로 변환하는 과정을 말한다. (목적파일이 생성됨)

즉, 컴퓨터가 이해할 수 있는 기계어로 변환하는 작업이다. 이러한 작업을 해주는 프로그램을 가르켜 컴파일러(Compiler)라 한다.

자바의 경우, 자바가상머신(JVM)에서 실행가능한 바이트코드 형태의 클래스파일이 생성이 된다.

프로젝트를 진행하다 보면 소스파일이 여러개가 생성이되고 A라는 소스파일에서 B라는 소스파일에 존재하는 함수(메서드)를 호출하는 경우가 있다.

이때 A와 B 소스파일 각각을 컴파일만 하면 A가 B에 존재하는 함수를 찾질 못하기 때문에 호출할 수가 없다.

따라서 A와 B를 연결해주는 작업이 필요한데 이 작업을 링크라고 한다.

여러개로 분리된 소스파일들을 컴파일한 결과물들에서 최종 실행가능한 파일을 만들기 위해 필요한 부분을 찾아서 연결해주는 작업이다.

링크는 정적링크(static link)와 동적링크(dynamic link)가 있는데

정적링크란 컴파일된 소스파일을 연결해서 실행가능한 파일을 만드는 것이고, 동적링크란 프로그램 실행 도중 프로그램 외부에 존재하는 코드를 찾아서 연결하는 작업을 말한다.

자바의 경우, JVM이 프로그램 실행 도중 필요한 클래스를 찾아서 클래스패스에 로드해주는데 이는 동적링크의 예이다.

소스코드 파일을 실행가능한 소프트웨어 산출물로 만드는 일련의 과정을 말한다.

빌드의 단계 중 컴파일이 포함이 되어 있는데 컴파일은 빌드의 부분집합이라 할 수 있다.

빌드 과정을 도와주는 도구를 빌드 툴이라 한다.

일반적으로 빌드 툴이 제공해주는 기능으로는 다음과 같은 기능들이 있다.

전처리(preprocessing), 컴파일(Compile), 패키징(packaging), 테스팅(testing), 배포(distribution)

빌드 툴로는 Ant, Maven, Gradle 등이 있다.

출처: https://itwiki.kr/w/Twelve_Factor_%EB%B0%A9%EB%B2%95%EB%A1%A0 출처: https://freezboi.tistory.com/39 [코딩 공작소]