마이크로서비스 아키텍처 구축: 대용량 시스템의 효율적인 분산 설계 기법

Table of contents

1. 마이크로서비스 아키텍처 구축
   1. 지은이·옮긴이 소개
   2. 추천의 글
   3. 옮긴이의 말
   4. 이 책에 대하여
   5. 감사의 글 (1/3)
   6. 감사의 글 (2/3)
   7. 감사의 글 (3/3)
2. CHAPTER 1 마이크로서비스
   1. 1.1. 마이크로서비스란
      1. 1.1.1. 작고, 한 가지 일을 잘하는 데 주력
      2. 1.1.2. 자율성
   2. 1.2. 주요 혜택
      1. 1.2.1. 기술 이기종성
      2. 1.2.2. 회복성
      3. 1.2.3. 확장성
      4. 1.2.4. 배포 용이성
      5. 1.2.5. 조직 부합성
      6. 1.2.6. 조합성
      7. 1.2.7. 대체 가능성을 위한 최적화
   3. 1.3. 서비스 지향 아키텍처란
   4. 1.4. 기타 분해 기술
      1. 1.4.1. 공유 라이브러리
      2. 1.4.2. 모듈
   5. 1.5. 은총알은 없다
   6. 1.6. 마치며
3. CHAPTER 2 진화적 아키텍트
   1. 2.1. 부정확한 비교
   2. 2.2. 아키텍트에 대한 진화적 관점
   3. 2.3. 구역화
   4. 2.4. 원칙적인 접근법
      1. 2.4.1. 전략적 목표
      2. 2.4.2. 원칙
      3. 2.4.3. 실천 사항
      4. 2.4.4. 원칙과 실천 사항의 결합
      5. 2.4.5. 실제 사례
   5. 2.5. 필수 기준
      1. 2.5.1. 모니터링
      2. 2.5.2. 인터페이스
      3. 2.5.3. 아키텍처 안정성
   6. 2.6. 코드를 통한 통제
      1. 2.6.1. 본보기
      2. 2.6.2. 맞춤형 서비스 템플릿
   7. 2.7. 기술 부채
   8. 2.8. 예외 처리
   9. 2.9. 중앙에서의 거버넌스와 지휘
   10. 2.10. 팀 만들기
   11. 2.11. 마치며
4. CHAPTER 3 서비스 모델링하기
   1. 3.1. 뮤직코퍼레이션 소개
   2. 3.2. 무엇이 좋은 서비스를 만드는가?
      1. 3.2.1. 느슨한 결합
      2. 3.2.2. 강한 응집력
   3. 3.3. 경계가 있는 콘텍스트
      1. 3.3.1. 감춰진 공유 모델
      2. 3.3.2. 모듈과 서비스
      3. 3.3.3. 성급한 분해
   4. 3.4. 비즈니스 능력
   5. 3.5. 거북이 밑에 거북이
   6. 3.6. 비즈니스 콘셉트 관점에서의 커뮤니케이션
   7. 3.7. 기술적 경계
   8. 3.8. 마치며
5. CHAPTER 4 통합
   1. 4.1. 이상적인 통합 기술 모색
      1. 4.1.1. 호환성을 깨뜨리는 변경 피하기
      2. 4.1.2. 기술 중립적인 API 생성
      3. 4.1.3. 소비자를 위한 서비스 단순화
      4. 4.1.4. 내부 구현 상세 감추기
   2. 4.2. 고객과의 인터페이싱
   3. 4.3. 공유 데이터베이스
   4. 4.4. 동기와 비동기
   5. 4.5. 오케스트레이션과 코레오그래피
   6. 4.6. 원격 프로시저 호출
      1. 4.6.1. 기술 결합
      2. 4.6.2. 지역 호출은 원격 호출과 다르다
      3. 4.6.3. 취성
      4. 4.6.4. RPC는 형편없는가?
   7. 4.7. REST
      1. 4.7.1. REST와 HTTP
      2. 4.7.2. 애플리케이션 상태 엔진으로서의 하이퍼미디어
      3. 4.7.3. JSON, XML 또는 다른 것?
      4. 4.7.4. 지나친 편의를 주의하라
      5. 4.7.5. HTTP 기반 REST의 단점
   8. 4.8. 비동기 이벤트 기반의 협업 구현
      1. 4.8.1. 기술 선택
      2. 4.8.2. 비동기 아키텍처의 복잡성
   9. 4.9. 상태 기계로서의 서비스
   10. 4.10. 반응형 확장
   11. 4.11. 마이크로서비스 세계에서 코드 재사용의 위험과 DRY
       1. 4.11.1. 클라이언트 라이브러리
   12. 4.12. 참조에 의한 접근
   13. 4.13. 버전 관리
       1. 4.13.1. 가능하면 지연하기
       2. 4.13.2. 호환성을 깨뜨리는 변경 일찍 찾아내기
       3. 4.13.3. 유의적 버전 관리
       4. 4.13.4. 다른 엔드포인트와 공존
       5. 4.13.5. 다수의 병행 서비스 버전 사용하기
   14. 4.14. 사용자 인터페이스
       1. 4.14.1. 디지털을 향해
       2. 4.14.2. 제약
       3. 4.14.3. API 구성
       4. 4.14.4. UI 부분 구성
       5. 4.14.5. 프론트엔드를 위한 백엔드
       6. 4.14.6. 하이브리드 방식
   15. 4.15. 외부 소프트웨어와 통합
       1. 4.15.1. 통제 부족
       2. 4.15.2. 맞춤화
       3. 4.15.3. 스파게티 통합
       4. 4.15.4. 여러분 방식대로
       5. 4.15.5. 교살자 패턴
   16. 4.16. 마치며
6. CHAPTER 5 모놀리스 분해하기
   1. 5.1. 접합부가 중요하다
   2. 5.2. 뮤직코퍼레이션 분해하기
   3. 5.3. 모놀리스를 분리하는 이유
      1. 5.3.1. 변경의 속도
      2. 5.3.2. 팀 구조
      3. 5.3.3. 보안
      4. 5.3.4. 기술
   4. 5.4. 뒤엉킨 의존성
   5. 5.5. 데이터베이스
   6. 5.6. 문제에 대처하기
   7. 5.7. 예: 외부 키 관계 깨뜨리기
   8. 5.8. 예: 공유 정적 데이터
   9. 5.9. 예: 공유 데이터
   10. 5.10. 예: 공유 테이블
   11. 5.11. 데이터베이스 리팩토링
       1. 5.11.1. 단계적인 분리
   12. 5.12. 트랜잭션의 경계
       1. 5.12.1. 나중에 재시도하기
       2. 5.12.2. 전체 작업 중지하기
       3. 5.12.3. 분산 트랜잭션
       4. 5.12.4. 그렇다면 무엇을 해야 할까?
   13. 5.13. 리포팅
   14. 5.14. 리포팅 데이터베이스
   15. 5.15. 서비스 호출을 통한 데이터 추출
   16. 5.16. 데이터 펌프
       1. 5.16.1. 대체 종착지
   17. 5.17. 이벤트 데이터 펌프
   18. 5.18. 백업 데이터 펌프
   19. 5.19. 실시간을 향해
   20. 5.20. 변경 비용
   21. 5.21. 원인 파악
   22. 5.22. 마치며
7. CHAPTER 6 배포
   1. 6.1. 지속적 통합이란
      1. 6.1.1. 정말로 하고 있는가?
   2. 6.2. 지속적 통합을 마이크로서비스로 매핑하기
   3. 6.3. 빌드 파이프라인과 지속적 배포
      1. 6.3.1. 그리고 피할 수 없는 예외
   4. 6.4. 플랫폼별 산출물
   5. 6.5. 운영 체제 산출물
   6. 6.6. 커스텀 이미지
      1. 6.6.1. 산출물로서의 이미지
      2. 6.6.2. 불변 서버
   7. 6.7. 환경
   8. 6.8. 서비스 환경 구성
   9. 6.9. 서비스와 호스트 매핑
      1. 6.9.1. 호스트당 다수의 서비스
      2. 6.9.2. 애플리케이션 컨테이너
      3. 6.9.3. 호스트당 단일 서비스
      4. 6.9.4. 서비스로서의 플랫폼
   10. 6.10. 자동화
       1. 6.10.1. 자동화의 위력에 대한 두 가지 사례 연구
   11. 6.11. 물리 머신에서 가상화로
       1. 6.11.1. 전통적 가상화
       2. 6.11.2. 베이그런트
       3. 6.11.3. 리눅스 컨테이너
       4. 6.11.4. 도커
   12. 6.12. 배포 인터페이스
       1. 6.12.1. 환경 정의
   13. 6.13. 마치며
8. CHAPTER 7 테스팅
   1. 7.1. 테스트의 종류
   2. 7.2. 테스트의 범위
      1. 7.2.1. 단위 테스트
      2. 7.2.2. 서비스 테스트
      3. 7.2.3. 엔드 투 엔드 테스트
      4. 7.2.4. 절충안
      5. 7.2.5. 얼마나 많은 테스트가 필요할까?
   3. 7.3. 서비스 테스트 구현하기
      1. 7.3.1. 목 또는 스텁 사용하기
      2. 7.3.2. 더 영리한 스텁 서비스
   4. 7.4. 까다로운 엔드 투 엔드 테스트
   5. 7.5. 엔드 투 엔드 테스팅의 단점
   6. 7.6. 신뢰할 수 없고 취약한 테스트
      1. 7.6.1. 누가 이 테스트를 작성하는가?
      2. 7.6.2. 얼마나 오래 걸릴까?
      3. 7.6.3. 엄청난 적체
      4. 7.6.4. 메타버전
   7. 7.7. 스토리가 아닌 테스트 여정
   8. 7.8. 우리를 구할 소비자 주도 테스트
      1. 7.8.1. 팩트
      2. 7.8.2. 대화에 관하여
   9. 7.9. 엔드 투 엔드 테스트를 사용해야 하는가?
   10. 7.10. 출시 후의 테스팅
       1. 7.10.1. 배포를 릴리스와 분리하기
       2. 7.10.2. 카나리아 릴리스
       3. 7.10.3. MTBF보다 MTTR?
   11. 7.11. 교차기능 테스트
       1. 7.11.1. 성능 테스트
   12. 7.12. 마치며
9. CHAPTER 8 모니터링
   1. 8.1. 단일 서비스, 단일 서버
   2. 8.2. 단일 서비스, 다수 서버
   3. 8.3. 다수 서비스, 다수 서버
   4. 8.4. 로그, 로그, 더 많은 로그
   5. 8.5. 다수 서비스 간의 측정지표 추적
   6. 8.6. 서비스 측정지표
   7. 8.7. 합성 모니터링
      1. 8.7.1. 유의적 모니터링 구현하기
   8. 8.8. 상관관계 ID
   9. 8.9. 전파
   10. 8.10. 표준화
   11. 8.11. 관객 고려하기
   12. 8.12. 앞으로
   13. 8.13. 마치며
10. CHAPTER 9 보안
    1. 9.1. 인증과 권한부여
       1. 9.1.1. 일반적인 SSO 구현체
       2. 9.1.2. 싱글 사인온 게이트웨이
       3. 9.1.3. 세분화된 권한 부여
    2. 9.2. 서비스 대 서비스 인증과 권한부여
       1. 9.2.1. 경계 안의 모든 것 허용하기
       2. 9.2.2. HTTP(S) 기본 인증
       3. 9.2.3. SAML 또는 OpenID Connect 사용하기
       4. 9.2.4. 클라이언트 인증서
       5. 9.2.5. HTTP 기반의 HMAC
       6. 9.2.6. API 키
       7. 9.2.7. 대리인 문제
    3. 9.3. 보관 중인 데이터 보호하기
       1. 9.3.1. 잘 알려진 것을 사용하라
       2. 9.3.2. 키가 전부다
       3. 9.3.3. 암호화 대상 정하기
       4. 9.3.4. 요구형 복호화
       5. 9.3.5. 백업 암호화하기
    4. 9.4. 심층 방어
       1. 9.4.1. 방화벽
       2. 9.4.2. 로깅
       3. 9.4.3. 침입 탐지와 방지 시스템
       4. 9.4.4. 네트워크 분리(망 분리)
       5. 9.4.5. 운영 체제
    5. 9.5. 시범 예제
    6. 9.6. 절약하라
    7. 9.7. 인적 요소
    8. 9.8. 황금률
    9. 9.9. 보안 탑재
    10. 9.10. 외부 검증
    11. 9.11. 마치며
11. CHAPTER 10 콘웨이의 법칙과 시스템 설계
    1. 10.1. 증거
       1. 10.1.1. 느슨히 결합된 조직과 강력히 결합된 조직
       2. 10.1.2. 윈도우 비스타
    2. 10.2. 넷플릭스와 아마존
    3. 10.3. 이것으로 무엇을 할 수 있을까?
    4. 10.4. 의사소통 경로 적응
    5. 10.5. 서비스 소유권
    6. 10.6. 공유 서비스의 추진
       1. 10.6.1. 분리의 어려움
       2. 10.6.2. 제품 특징 팀
       3. 10.6.3. 전달 병목점
    7. 10.7. 내부 오픈 소스
       1. 10.7.1. 관리인의 역할
       2. 10.7.2. 성숙도
       3. 10.7.3. 도구
    8. 10.8. 경계가 있는 콘텍스트와 팀 구조
    9. 10.9. 방치된 서비스
    10. 10.10. 사례 연구: RealEstate.com.au
    11. 10.11. 콘웨이의 역법칙
    12. 10.12. 사람
    13. 10.13. 마치며
12. CHAPTER 11 대규모 마이크로서비스
    1. 11.1. 장애는 어디에서나 발생한다
    2. 11.2. 얼마나 많아야 너무 많은 건가?
    3. 11.3. 기능 분해
    4. 11.4. 아키텍처 안전 조치
    5. 11.5. 안티프래질 조직
       1. 11.5.1. 타임아웃
       2. 11.5.2. 회로 차단기
       3. 11.5.3. 격벽
       4. 11.5.4. 격리
    6. 11.6. 멱등성
    7. 11.7. 확장
       1. 11.7.1. 더 크게 만들기
       2. 11.7.2. 작업부하 나누기
       3. 11.7.3. 위험 분산
       4. 11.7.4. 부하 분산
       5. 11.7.5. 작업자 기반 시스템
       6. 11.7.6. 다시 시작하기
    8. 11.8. 데이터베이스 확장
       1. 11.8.1. 서비스의 가용성과 데이터의 내구성
       2. 11.8.2. 읽기용 확장
       3. 11.8.3. 쓰기용 확장
       4. 11.8.4. 공유 데이터베이스 인프라스트럭처
       5. 11.8.5. CQRS
    9. 11.9. 캐싱
       1. 11.9.1. 클라이언트 측, 프록시, 그리고 서버 측 캐싱
       2. 11.9.2. HTTP의 캐싱
       3. 11.9.3. 쓰기용 캐싱
       4. 11.9.4. 회복성을 위한 캐싱
       5. 11.9.5. 원본 감추기
       6. 11.9.6. 단순화하라
       7. 11.9.7. 캐시 중독: 경계할 일화
    10. 11.10. 자동 확장
    11. 11.11. CAP 정리
        1. 11.11.1. 일관성 희생하기
        2. 11.11.2. 가용성 희생하기
        3. 11.11.3. 분할용인 희생하기?
        4. 11.11.4. AP 또는 CP?
        5. 11.11.5. 양자택일이 아니다
        6. 11.11.6. 그리고 현실세계
    12. 11.12. 서비스 발견
        1. 11.12.1. DNS
    13. 11.13. 동적 서비스 레지스트리
        1. 11.13.1. 주키퍼
        2. 11.13.2. 칸슬
        3. 11.13.3. 유레카
        4. 11.13.4. 직접 만들기
        5. 11.13.5. 사람을 잊지 마라!
    14. 11.14. 문서화 서비스
        1. 11.14.1. 스웨거
        2. 11.14.2. HAL과 HAL 브라우저
    15. 11.15. 자기 기술 시스템
    16. 11.16. 마치며
13. CHAPTER 12 종합 정리
    1. 12.1. 마이크로서비스의 원칙
       1. 12.1.1. 비즈니스 개념에 따른 모델
       2. 12.1.2. 자동화 문화의 적용
       3. 12.1.3. 내부 세부 구현의 은폐
       4. 12.1.4. 모든 것을 분권화
       5. 12.1.5. 독립적인 배포
       6. 12.1.6. 장애 격리
       7. 12.1.7. 매우 식별 가능한
    2. 12.2. 언제 마이크로서비스를 사용하지 않아야 하는가?
    3. 12.3. 이 책을 마치며
14. 찾아보기 (1/3)
15. 찾아보기 (2/3)
16. 찾아보기 (3/3)