@GetMapping("second-service/check")
public String checkSecond(){
return "Hi, there, second check";
}
@GetMapping("first-service/check")
public String checkFirst(){
return "Hi, there, first check";
}
MSA의 개발, 배포, 운영에 필요한 아키텍쳐를 쉽게 구성할 수 있도록 지원하는 Spring Boot 기반 프레임워크
분산 시스템 상에 필요한 여러 패턴들을 표준 패턴화 시켜 손쉽게 개발할 수 있도록 지원함
어떤 서비스가 사용되어야 할까?
Spring Cloud Config Server
환경 설정관리를 위함
다양한 마이크로서비스에서 사용하는 정보를 SpringCloudConfigServer를 통해 외부의 저장소에 저장할 수 있다.
유지보수성이 높아진다.
Location transparency
서비스 등록과 위치정보 확인 Naming Server(Eureka)
Load Distribution(Load Balancing)
Ribbon (Client Side)
Spring Cloud Gateway(권장)
Easier REST Clients
각각의 서비스가 데이터를 주고 받는 방법(RestTemplate , Feign Client)
Visibility and monitoring
ELK 등등 (로그 추적 및 모니터링)
Fault Tolerance
Hystrix
서비스의 지연과 장애에 대해 내성을 갖게 해주는 라이브러리
Spring Cloud Netflix Eureka
Service Discovery
외부에서 다른 서비스들이 마이크로 서비스를 검색하기 위해 사용되는 일종의 전화번호책이다.
API gateway에다가 요청을 보내고 요청 정보가 서비스 디스커버리에 전달되어 필요한 서비스의 위치를 알려준다.
Eureka 서버 구동 확인 및 application.yml
server:
port: 8761
spring:
application:
name: discoveryservice
eureka:
# 이 설정의 default가 true -> 자기 자신을 전화번호부에 등록하는 것은 의미 없는 행위
client:
register-with-eureka: false
fetch-registry: false
Eureka 서버에 등록된 userService 구동 확인 및 application.yml
server:
port: 9001
spring:
application:
name: user-service
eureka:
client:
register-with-eureka: true
# Eureka 서버로 부터 인스턴스들의 정보를 주기적으로 가져올 것인지
# 설정하는 속성 -> fetch-registry = true 갱신 된 정보를 받겠다는 설정
fetch-registry: true
service-url:
defaultZone: http://127.0.0.1:8761/eureka
같은 서비스를 하나 더 띄워보자
application.yml 파일 내부의 port설정을 동적으로 추가해주는 코드를 넣고
edit configurations에서 환경변수를 추가해주어야 한다
그렇지 않으면 포트번호가 겹치게 되어 실행 오류가 남
server:
port: ${PORT}
spring:
application:
name: user-service
eureka:
client:
register-with-eureka: true
# Eureka 서버로 부터 인스턴스들의 정보를 주기적으로 가져올 것인지
# 설정하는 속성 -> fetch-registry = true 갱신 된 정보를 받겠다는 설정
fetch-registry: true
service-url:
defaultZone: http://127.0.0.1:8761/eureka
server:
# 0의 의미 랜덤 포트를 사용하겠다는 의미! 포트 충돌을 의식하지 않아도 되는 장점이 있다.
port: 0
spring:
application:
name: user-service
eureka:
############해당 설정 ###############
instance:
instance-id: ${spring.cloud.client.hostname}:${spring.application.instance_id:${random.value}}
############해당 설정 ###############
client:
register-with-eureka: true
# Eureka 서버로 부터 인스턴스들의 정보를 주기적으로 가져올 것인지
# 설정하는 속성 -> fetch-registry = true 갱신 된 정보를 받겠다는 설정
fetch-registry: true
service-url:
defaultZone: http://127.0.0.1:8761/eureka
자바의 문자열은 불변이다. String의 함수를 호출을 하면 해당 객체를 직접 수정하는 것이 아니라, 함수의 결과로 해당 객체가 아닌 다른 객체를 반환한다. 그러나 항상 그런 것은 아니다.
대문자로 문자열 생성 후 String의 toUpperCase()를 호출하면 내부 구현에서 lower case의 문자가 발견되지 않으면 기존의 객체를 반환한다.
문자열변수.interen()을 하게되면
해당 문자열과 동일한 값을 가진 문자열을 상수풀에서 찾고 있다면 해당 문자열을 바라보게 하고 없다면 새로 생성하여 반환합니다.
언제 사용될까?
만약 문자열을 == 비교연산으로 비교해야 한다면. intern() 메서드가 사용될 수 있다. 해당 메서드에서 상수풀을 찾아 같은 값을 가지고 있다면 해당 참조를 반환해주기 때문에 속도가 더 빠를 수 있지만 해당 문자열이 상수풀에 없을때는 equals보다 느릴 수 도 있다. 상황에 따라 잘 사용해야할 것 같다!
사용자는 작업을 kubuctl을 통해서 컨트롤 플레인에게 api 호출만 해주면 된다. 실제 컨테이너가 동작하는 위치는 노드의 파드 단위로 배포되어 동작한다.
컨트롤 플레인
kube-APIserver
클러스터의 모든 명령을 수락하는 진입점
etcd
클러스터의 상태를 안정적으로 저장하는 역할(키밸류형태로 저장)
kube-scheduler
파드를 노드에 예약하는 역할
파드를 분산하고 어디에 배포하면 좋을지 정해주는 역할
kube-controller-manager
상태를 지속적으로 모니터링하고 바람직한 상태를 달성하기 위해 변경을 시도
kube-cloud-manager
클라우드 제공업체와 상호작용하는 컨트롤러를 관리
노드
kubelet
컨테이너 런타임을 사용하여 파드를 시작
kube-proxy
클러스터의 파드 간에 네트워크 연결을 유지
왜 파드 단위로 배포를 할까?
애플리케이션이 동작을 하고 있고 동작하면서 어떤 작업을 했는지 로그 등이 남는다고 했을때 다른 컨테이너는 로그를 전송해서 수집하는 작업을 할 수 있다.
마치 파드를 가상의 서버 같은 것이라고 생각을 하면 된다.!
공유된 스토리지를 할 수 있고, 통신을 별도의 인터페이스 없이 할 수 있다.
GCP 실습해보기
create cluster
Autopilot
클라우드측에서 데이터 플레인 마저 숨기게 된다.
띄운 파드만큼만 과금이 된다.
Standard
클라우드측에서 컨트롤 플레인에 대한 부분은 숨겨놓는다. 접근 불가!
접근 가능한 곳은 데이터 플레인
노드당 과금이 일어난다.
노드들을 사용자가 관리한다.
파드가 떠있건 말건 노드가 떠있으면 과금이된다.
실습을 위해 스탠다드 선택!
location type
Zonal
zone
쿠버네티스 클러스터 내에서 물리적으로 분리된 영역을 의미. 예를 들어, 클라우드 제공 업체(GCP, AWS 등)에서 제공하는 가용 영역(Availability Zone)과 비슷한 개념입니다. 하나의 클러스터 내에서 여러 개의 Zone을 사용하여 고가용성(High Availability)을 보장할 수 있다.
Regional
컨트롤 플레인이 삼중화가 된다.
Region
클러스터를 호스팅하는 물리적인 지역을 의미. 예를 들어, GCP의 us-central1, asia-northeast1 등과 같은 지역 개념. 여러 개의 클러스터를 하나의 Region에서 운영할 수 있으며, 이는 지리적으로 분산된 애플리케이션을 구성하는 데 유용하다.
노드가 3개가 뜬 것을 확인할 수 있다! 컨트롤 플레인은 보이지 않고 사용자는 컨트롤 플레인의 apiServer에게 명령만 할 수 있다.
SDN
**SDN(Software Defined Network)**이란 소프트웨어를 통해 네트워크 리소스를 가상화하고 추상화하는 네트워크 인프라에 대한 접근 방식을 의미한다.
조금 더 쉽게 설명하자면, 소프트웨어 애플리케이션과 API를 이용하여 네트워크를 프로그래밍하고, 중앙에서 전체 네트워크를 제어하고 관리하는 것이다.
Pod
배포 가능한 가장 작은 쿠버네티스 객체
공유된 네트워킹, 공유된 스토리지를 사용한다.
마치 하나의 pc같다. 컨테이너는 프로그램(엑셀, 등등) 필요한 프로그램이 논리적인 단위로 묶여있는 형태
OutOfMemory : JVM에서 설정된 메모리의 한계를 벗어난 상황일 때 발생. 힙 사이즈가 부족하거나 너무 많은 class를 로드할때, 가용가능한 swap이 없을때 큰 메모리의 native 메서드가 호출될때 등이 있다. 이를 해결하기 위해 dump파일분석, jvm 옵션 수정 등이 있다.
자바는 멀티스레드 환경에서 동기화를 지원하기 위해 가장 기초적인 장치인 ’고유 락(Intrinsic Lock)’을 지원한다. 개발자는 synchronized 키워드를 이용해서 특정 객체의 고유락을 사용해 여러 스레드를 동기화 시킬 수 있다.
Synchronized 블록은 Intrinsic Lock을 이용해서, Thread의 접근을 제어한다.
Java의 synchronized
동일한 객체에 대해 synchronized 블록을 사용하는 두 스레드는 한 번에 하나의 스레드만 내부로 들어갈 수 있고, 이 것이 자바가 제공하는 가장 기본적인 ‘상호배제(Mutual Exclusion)’ 장치이다.
synchronized에는 4가지의 사용법이 있다.
synchronized method
synchronized block
static synchronized method
static synchronized block
4가지 방식의 차이인 lock이 적용되는 범위를 알아보자
1. synchronized method
synchronized method는 클래스의 인스턴스에 대하여 lock을 건다.
하나의 인스턴스에 대하여 2개의 thread가 경합하는 상황
public class Main {
public static void main(String[] args) {
A a = new A();
Thread thread1 = new Thread(()->{
a.run("t1");
});
Thread thread2 = new Thread(()->{
a.run("t2");
});
thread1.start();
thread2.start();
}
}
public class A {
public synchronized void run(String name){
System.out.println(name + "lock");
try{
Thread.sleep(1000);
} catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(name + "unlock");
}
}
순서대로 lock을 획득하고 반납함
실행 결과
t1lock t1unlock t2lock t2unlock
각각의 인스턴스를 만들고 실행 해보자
public class Main {
public static void main(String[] args) {
A a = new A();
A a1 = new A();
Thread thread1 = new Thread(()->{
a.run("t1");
});
Thread thread2 = new Thread(()->{
a1.run("t2");
});
thread1.start();
thread2.start();
}
}
lock을 공유하지 않기 때문에 동기화가 발생하지 않음
실행 결과
t1lock t2lock t1unlock t2unlock
결과
synchronized method는 인스턴스에 대하여 lock을 건다.
인스턴스에 대해서 lock을 건다라는 표현이 인스턴스 접근 자체가 lock이 걸리는 걸까?? 확인해보자
public class Main {
public static void main(String[] args) throws InterruptedException {
A a = new A();
Thread thread1 = new Thread(()->{
a.run("t1");
});
Thread thread2 = new Thread(()->{
a.print("t2");
});
thread1.start();
Thread.sleep(500);
thread2.start();
}
}
public class A {
public void print(String name){
System.out.println(name + " hi");
}
public synchronized void run(String name){
System.out.println(name + "lock");
try{
Thread.sleep(1000);
} catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(name + "unlock");
}
}
synchronized가 적용되지 않은 print() 메서드를 추가하고 lock이 걸린 중간에 호출 해보았더니 run() 메서드의 lock과 상관없이 정상적으로 호출됨
static이 포함된 synchronized method방식은 우리가 일반적으로 생각하는 static 성질을 갖는다. 인스턴스가 아닌 클래스 단위로 lock이 발생한다.
public class Main {
public static void main(String[] args) throws InterruptedException {
A a1 = new A();
A a2 = new A();
Thread thread1 = new Thread(()->{
a1.run("t1");
});
Thread thread2 = new Thread(()->{
a2.run("t2");
});
thread1.start();
thread2.start();
}
}
public class A {
public static synchronized void run(String name){
System.out.println(name + "lock");
try{
Thread.sleep(1000);
} catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(name + "unlock");
}
}
실행 결과
t1lock t1unlock t2lock t2unlock
다른 인스턴스 이지만 클래스 단위로 lock이 발생했다.
만약 static synchronized method와 synchronized method가 섞여있다면 어떨까?
public class Main {
public static void main(String[] args) throws InterruptedException {
A a1 = new A();
A a2 = new A();
Thread thread1 = new Thread(()->{
a1.run("t1");
});
Thread thread2 = new Thread(()->{
a2.print("t2");
});
thread1.start();
thread2.start();
}
}
public class A {
public synchronized void print(String name){
System.out.println(name + " hi");
}
public static synchronized void run(String name){
System.out.println(name + "lock");
try{
Thread.sleep(1000);
} catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(name + "unlock");
}
}
실행 결과
t1lock t2 hi t1unlock
인스턴스 단위의 lock과 클래스 단위의 lock은 공유되지 않았다.
static synchronized method를 정리해보면
클래스 단위로 lock을 걸지만
인스턴스 단위의 synchronized method와 lock을 공유하지 않는다.
3. synchronized block
synchronized block은 인스턴스의 block단위로 lock을 건다. 이 때, lock 객체를 지정해줘야 한다.
public class Main {
public static void main(String[] args) throws InterruptedException {
A a1 = new A();
Thread thread1 = new Thread(()->{
a1.run("t1");
});
Thread thread2 = new Thread(()->{
a1.run("t2");
});
thread1.start();
thread2.start();
}
}
public class A {
public void run(String name) {
synchronized (this) {
System.out.println(name + "lock");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + "unlock");
}
}
}
실행 결과
t1lock t1unlock t2lock t2unlock
block의 인자로 this를 주었다.
this는 해당 인스턴스를 의미하고 위 코드에서 method 전체가 block으로 감싸져 있으므로 메서드 선언부에 synchronized 키워드를 붙인 것과 똑같이 동작한다.
하지만 여러 로직이 섞여 있는 사이 부분만 lock을 걸 수 있다. lock은 synchronized block에 진입할 때 획득하고 빠져나오면서 반납하므로 block으로 범위를 지정하는 것이 효율적이다.
synchronized block도 method와 동일하게 인스턴스에 대해서 적용된다.
지금까지는 block에 인자로 this를 사용해서 Synchronized를 메서드 선언부에 붙인 것과 별반 다를 것 없이 사용함
이제는 block에 자원을 명시하고 사용
public class Main {
public static void main(String[] args) throws InterruptedException {
A a = new A();
Thread thread1 = new Thread(() -> {
a.run("thread1");
});
Thread thread2 = new Thread(() -> {
a.run("thread2");
});
Thread thread3 = new Thread(() -> {
a.print("자원 B와 상관 없는 thread3");
});
thread1.start();
thread2.start();
thread3.start();
}
}
public class A {
B b = new B();
public void run(String name) {
synchronized (b){
System.out.println(name + " lock");
b.run();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + " unlock");
}
}
public synchronized void print(String name) {
System.out.println(name + " hello");
}
}
public class B extends Thread{
@Override
public synchronized void run() {
System.out.println("B lock");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("B unlock");
}
}
실행 결과
thread1 lock 자원 B와 상관 없는 thread3 hello B lock B unlock thread1 unlock thread2 lock B lock B unlock thread2 unlock
매우 복잡한 상황이다. lock 객체를 A클래스가 아닌 B클래스의 인스턴스로 사용하고 있다.
thread1, thread2는 b를 사용하는 method를 호출하고 있지만
thread3은 b와 상관없는 method이기 때문에 b의 lock과 상관없이 출력되었다.
즉 인스턴스 단위 lock과 B를 block한 lock은 공유되지 않고 별도로 관리되는 것을 확인할 수 있다.
이번에는 block에 인스턴스가 아니라 class를 명시해보았다.
public class Main {
public static void main(String[] args) {
A a = new A();
Thread thread1 = new Thread(() -> {
a.run("thread1");
});
Thread thread2 = new Thread(() -> {
a.run("thread2");
});
thread1.start();
thread2.start();
}
}
public class A {
B b = new B();
public void run(String name) {
synchronized (B.class){
System.out.println(name + " lock");
b.run();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + " unlock");
}
}
public synchronized void print(String name) {
System.out.println(name + " hello");
}
}
public class B extends Thread{
@Override
public synchronized void run() {
System.out.println("B lock");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("B unlock");
}
}
실행 결과
thread1 lock B lock B unlock thread1 unlock thread2 lock B lock B unlock thread2 unlock
block의 인자로 인스턴스가 아닌 .class를 주었다.
출력 결과를 보면 lock을 공유하고 있는 것을 확인할 수 있다.
block에는 객체를 넘기면 인스턴스 단위로 lock을 걸고, .class형식으로 넘기면 클래스 단위의 lock을 건다.
4. static synchronized block
static method안에 synchronized block을 지정할 수 있다. static의 특성 상 this같이 현재 객체를 가르키는 표현을 사용할 수 없다. static synchronized method 방식과 차이는 lock 객체를 지정하고 block으로 범위를 한정지을 수 있다는 점이다. 이외에 클래스 단위로 lock을 공유한다는 점은 같다.
public class Main {
public static void main(String[] args) {
A a1 = new A();
A a2 = new A();
Thread thread1 = new Thread(() -> {
a1.run("thread1");
});
Thread thread2 = new Thread(() -> {
a2.run("thread2");
});
thread1.start();
thread2.start();
}
}
public class A {
public static void run(String name) {
synchronized (A.class){
System.out.println(name + " lock");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + " unlock");
}
}
}
