★ 이 책에서 다루는 내용 ★

■ 쿠버네티스 내부 구조
■ 클러스터상에서 컨테이너 배포
■ 클러스터 보안
■ 무중단 애플리케이션 업데이트

★ 이 책의 대상 독자 ★

주로 애플리케이션 개발자를 대상으로 하며, 운영면에서 필요한 애플리케이션 관리도 대략적으로 설명한다. 이것은 단일 서버 이상의 컨테이너화된 애플리케이션을 실행하고 관리하는 데 관심이 있는 모든 사람에게 적합하다는 의미다.
컨테이너 기술을 배우고 여러 관련 컨테이너를 규모에 맞게 조율하고 싶은 입문자와 전문 소프트웨어 엔지니어라면 쿠버네티스 환경에서 애플리케이션을 개발하고 최적화하고 실행하는 데 필요한 전문 지식을 배울 수 있다.
컨테이너 기술이나 쿠버네티스 관련 경험은 필요하지 않다. 주제를 점진적으로 설명하고 비전문가인 개발자가 이해하기 어려운 애플리케이션 소스 코드는 사용하지 않는다. 하지만 프로그래밍과 컴퓨터 네트워킹, 리눅스를 실행하는 기본 명령 정도는 알고 있어야 하며, HTTP처럼 잘 알려진 컴퓨터 프로토콜도 이해하고 있어야 한다.

★ 이 책의 구성 ★

이 책은 18개의 장을 세 개의 부로 나눠서 설명한다.

1부에서는 도커와 쿠버네티스를 간략하게 소개하고, 쿠버네티스 클러스터를 설정하는 방법과 간단한 애플리케이션 실행 방법을 설명한다. 1부에는 두 개의 장이 있다.
1장, '쿠버네티스 소개'에서는 쿠버네티스가 무엇인지, 어떻게 여기까지 오게 됐는지, 오늘날의 대규모 애플리케이션 관리 문제를 해결하는 데 도움이 되는 방법에 대해 설명한다.
2장, '도커와 쿠버네티스의 첫걸음'에서는 컨테이너 이미지를 작성하고 쿠버네티스 클러스터에서 실행하는 방법을 설명한다. 또한 클라우드에서 로컬 단일 노드 쿠버네티스 클러스터와 적절한 다중 노드 클러스터를 실행하는 방법도 설명한다.

2부에서는 쿠버네티스에서 애플리케이션을 실행하려면 반드시 알아야 하는 핵심 개념을 소개한다. 각 장은 다음과 같다.
3장 '포드: 쿠버네티스에서 컨테이너 실행하기'에서는 쿠버네티스의 기본 구성 블록(포드)을 소개하고 포드 및 기타 쿠버네티스 객체를 라벨로 구성하는 방법을 설명한다.
4장, '리플리케이션 및 기타 컨트롤러: 관리되는 포드 배포'에서는 쿠버네티스가 자동으로 컨테이너를 다시 시작해 애플리케이션을 정상으로 유지하는 방법을 설명한다. 또한 관리 포드를 올바르게 실행하고 수평으로 확장하며 클러스터 노드의 장애에 내성을 높이고 향후 사전 정의된 시간에 또는 주기적으로 실행하는 방법을 알아본다.
5장, '서비스: 클라이언트가 포드를 검색하고 대화를 가능하게 함'에서는 포드가 클러스터 내부 및 외부에서 실행되는 클라이언트에 제공하는 서비스를 어떻게 표현할 수 있는지 알려준다. 또한 클러스터에서 실행 중인 포드가 클러스터 내/외부에 상관없이 서비스를 검색하고 액세스하는 방법을 보여 준다.
6장, '볼륨: 컨테이너에 디스크 스토리지 연결하기'에서는 동일한 포드에서 실행 중인 여러 컨테이너가 파일을 공유하는 방법과 영구 스토리지를 관리하고 포드에 액세스할 수 있게 하는 방법을 설명한다.
7장, 'ConfigMaps와 Secrets: 애플리케이션 설정하기'에서는 설정 데이터와 자격 증명과 같은 중요한 정보를 포드 내부에서 실행되는 애플리케이션에 전달하는 방법을 보여준다.
8장, 애플리케이션에서 포드 메타데이터 및 기타 리소스에 접근하기'에서는 애플리케이션이 실행중인 쿠버네티스 환경에 대한 정보를 알아내는 방법과 쿠버네티스와 대화해 클러스터의 상태를 변경하는 방법을 설명한다.
9장, '디플로이먼트: 애플리케이션을 선언적으로 업데이트 하기'에서는 배포 개념을 소개하고 쿠버네티스 환경에서 애플리케이션을 실행하고 업데이트하는 올바른 방법을 설명한다.
10장, '스테이트풀셋: 복제된 스테이트풀 애플리케이션 배포하기'에서는 대개 안정적인 아이디와 상태가 필요한 스테이트풀 애플리케이션을 실행하는 전용 방법을 소개한다.

마지막으로 3부에서는 쿠버네티스 클러스터의 내부를 깊이 들여다보며 몇 가지 추가 개념을 소개하고, 앞서 배운 모든 내용을 넓은 관점에서 검토한다.
11장, '쿠버네티스 내부 이해하기'에서는 쿠버네티스를 구성하는 모든 컴포넌트와 각 컴포넌트의 역할을 설명한다. 또한 포드가 네트워크를 통해 통신하는 방법과 서비스가 여러 포드에서 로드밸런싱을 수행하는 방법도 설명한다.
12장, '쿠버네티스 API 서버 보안'에서는 인증 및 권한 부여를 통해 쿠버네티스 API 서버 및 확장 클러스터를 보호하는 방법을 설명한다.
13장, '클러스터 노드와 네트워크의 보안'에서는 포드가 노드의 리소스에 액세스할 수 있는 방법과 클러스터 관리자가 포드의 액세스를 방지하는 방법을 설명한다.
14장, '포드의 계산 리소스 관리'에서는 각 애플리케이션에서 계산 리소스의 사용을 제한하고 애플리케이션의 QoS(Quality of Service) 보장을 구성하며 개별 애플리케이션의 리소스 사용을 모니터링 한다. 또한 사용자가 너무 많은 리소스를 소비하지 못하게 하는 방법을 알려준다.
15장, '포드와 클러스터 노드의 오토스케일링'에서는 애플리케이션의 복제본을 자동으로 확장할 수 있게 쿠버네티스를 구성하는 방법과 현재 클러스터 노드 수가 추가 애플리케이션을 허용하지 않을 때 클러스터 크기를 늘리는 방법을 설명한다.
16장, '고급 스케줄링'에서는 포드가 특정 노드에만 스케줄되도록 하거나 포드가 다른 노드에 스케줄 되지 않도록 하는 방법을 보여준다. 그리고 포드가 함께 스케줄 됐는지 확인하는 방법이나 이러한 일이 발생하지 않도록 방지하는 방법을 보여준다.
17장, '애플리케이션 개발을 위한 Best Practice'에서는 애플리케이션을 개발해 클러스터의 구성원이 되는 방법을 설명한다. 또한 개발 중 마찰을 줄이기 위해 개발 및 테스트 워크플로우를 설정하는 방법에 대한 몇 가지 지침을 제공한다.
18장, '쿠버네티스 확장하기'에서는 사용자 지정 객체로 쿠버네티스를 확장하는 방법과 다른 사용자가 이를 수행하고 엔터프라이즈급 애플리케이션 플랫폼을 작성하는 방법을 보여준다.
이 장을 진행하면서 개별 쿠버네티스 컴포넌트에 대해 배울뿐만 아니라 kubectl 명령행 도구 사용에 대한 지식을 향상시킬 수 있다.

1부 OVERVIEW

1장. 쿠버네티스 소개
__1.1 쿠버네티스 시스템의 필요성 이해
____1.1.1 모놀리식 애플리케이션에서 마이크로서비스로 전환하기
____1.1.2 애플리케이션에 일관된 환경 제공
____1.1.3 지속적 전달로 이동: 데브옵스와 노옵스
__1.2. 컨테이너 기술 소개
____1.2.1 컨테이너 이해하기
____1.2.2 도커 컨테이너 플랫폼 소개
____1.2.3 rkt 소개: 도커의 대안
__1.3 쿠버네티스 소개
____1.3.1 쿠버네티스 기원에 대한 이해
____1.3.2 넓은 시각으로 쿠버네티스 바라보기
____1.3.3 쿠버네티스 클러스터 아키텍처 이해하기
____1.3.4 쿠버네티스에서 애플리케이션 실행하기
____1.3.5 쿠버네티스의 이점 이해하기
__1.4 요약

2장. 도커와 쿠버네티스의 첫걸음
__2.1 컨테이너 이미지의 생성, 실행, 공유
____2.1.1 도커를 설치하고 Hello World 컨테이너 실행하기
____2.1.2 간단한 Node.js 앱 만들기
____2.1.3 이미지용 도커 파일(Dockerfile) 만들기
____2.1.4 컨테이너 이미지 만들기
____2.1.6 실행 중인 컨테이너 내부 탐색
____2.1.7 컨테이너 중지 및 제거
____2.1.8 이미지 레지스트리로 이미지 푸시하기
__2.2 쿠버네티스 클러스터 설정
____2.2.1 미니큐브를 사용한 로컬의 단일 노드 쿠버네티스 클러스터 실행
____2.2.2 구글 쿠버네티스 엔진(GKE)에서 호스팅된 쿠버네티스 클러스터의 사용
____2.2.3 alias와 kubectl 명령행 셋업하기
__2.3 쿠버네티스에서 첫 번째 앱 실행하기
____2.3.1 Node.js 앱 배포
____2.3.2 웹 애플리케이션 액세스하기
____2.3.3 시스템의 논리적 부분
____2.3.4 애플리케이션 수평 확장하기
____2.3.5 앱이 실행되고 있는 노드 검사하기
____2.3.6 쿠버네티스 대시보드 소개
__2.4 요약


2부 CORE CONCEPTS

3장. 포드: 쿠버네티스에서 컨테이너 실행하기
__3.1 포드 소개
____3.1.2 포드의 필요성 이해하기
____3.1.2 포드 이해하기
____3.1.3 컨테이너를 포드 전체에 적절하게 구성하기
__3.2 YAML 혹은 JSON 파일 디스크립터로 포드 만들기
____3.2.1 기존 포드의 YAML 디스크립터 검사하기
____3.2.2 포드를 위한 간단한 YAML 디스크립터 만들기
____3.2.3 kubectl을 사용해 포드 만들기
____3.2.4 애플리케이션 로그보기
____3.2.5 포드에 요청 보내기
__3.3 라벨로 포드 구성하기
____3.3.1 라벨 소개
____3.3.2 포드를 만들 때 라벨 지정하기
____3.3.3 기존 포드의 라벨 수정하기
__3.4 라벨 셀렉터를 통한 하위 집합 나열하기
____3.4.1 라벨 셀렉터를 사용해 포드 나열하기
____3.4.2 라벨 셀렉터에서 다중 조건 사용하기
__3.5 포드 스케줄링 제약을 위한 라벨과 셀렉터 사용하기
____3.5.1 워커노드 분류를 위해 라벨 사용하기
____3.5.2 노드 지정을 위한 포드 스케줄링 하기
____3.5.3 하나의 지정된 포드에 스케줄링하기
__3.6 포드에 주석 달기
____3.6.1 객체의 주석 찾아보기
____3.6.2 주석 추가 및 수정하기
__3.7 그룹 리소스의 네임스페이스 사용하기
____3.7.1 네임스페이스의 필요성 이해하기
____3.7.2 다른 네임스페이스와 네임스페이스의 포드 찾아보기
____3.7.3 네임스페이스 만들기
____3.7.4 다른 네임스페이스의 객체 관리하기
____3.7.5 네임스페이스가 제공하는 격리에 대해 이해하기
__3.8 포드를 중지하고 삭제하기
____3.8.1 이름으로 포드 삭제하기
____3.8.2 라벨 셀렉터로 포드 삭제하기
____3.8.3 전체 네임스페이스를 삭제해서 포드 삭제하기
____3.8.4 네임스페이스가 유지되는 동안 모든 포드 삭제하기
____3.8.5 네임스페이스의 (거의)모든 리소스 삭제하기
__3.9 요약

4장. 리플리케이션 및 기타 컨트롤러: 관리되는 포드 배포
__4.1 포드를 안정적으로 유지하기
____4.1.1 liveness probe 소개
____4.1.2 HTTP 기반의 liveness probe생성
____4.1.3 동작 중인 liveness probe 보기
____4.1.4 liveness probe의 추가 속성 구성하기
____4.1.5 효과적인 liveness probe 생성하기
__4.2 리플리케이션컨트롤러 소개
____4.2.1 리플리케이션컨트롤러의 동작
____4.2.2 리플리케이션컨트롤러 생성하기
____4.2.3 실행 중인 리플리케이션컨트롤러 보기
____4.2.4 리플리케이션컨트롤러의 범위 안팎으로 포드 이동
____4.2.5 포드 템플릿 변경
____4.2.6 수평 포드 스케일링
____4.2.7 리플리케이션컨트롤러 삭제하기
__4.3 리플리케이션컨트롤러 대신 리플리카셋 사용
____4.3.1 리플리카셋과 리플리케이션컨트롤러 비교
____4.3.2 리플리카셋 정의
____4.3.3 리플리카셋 생성 및 검사
____4.3.4 리플리카셋의 더욱 풍부한 라벨 셀렉터 사용하기
____4.3.5 리플리카셋 정리하기
__4.4 데몬셋으로 각 노드에 정확히 한 개의 포드 실행하기
____4.4.1 데몬셋을 사용해 모든 노드에서 포드 실행
____4.4.2 데몬셋을 사용해 특정 노드에서 포드를 실행
__4.5 완료 가능한 단일 태스크를 수행하는 포드 실행
____4.5.1 잡 리소스 소개
____4.5.2 잡리소스의 정의
____4.5.3 포드를 실행하는 잡 보기
____4.5.4 잡에서 다수의 포드 인스턴스 실행
____4.5.5 잡 포드를 완료하는 데 허용되는 시간 제한
__4.6 잡을 주기적으로 또는 한번만 실행하도록 스케줄링
____4.6.1 CronJob 만들기
____4.6.2 스케줄된 잡의 실행 방법 이해
__4.7 요약

5장. 서비스: 클라이언트가 포드를 검색하고 대화를 가능하게 함
__5.1 서비스 소개하기
____5.1.1 서비스 생성하기
____5.1.2 서비스 검색하기
__5.2 클러스터 외부에 존재하는 서비스 연결하기
____5.2.1 서비스 엔드포인트 소개
____5.2.2 수동으로 서비스 엔드포인트 설정하기
____5.2.3 외부 서비스를 위한 별칭 생성
__5.3 외부 서비스에서 외부 클라이언트로
____5.3.1 NodePort 서비스 사용하기
____5.3.2 외부 로드 밸런서를 통해 서비스 노출하기
____5.3.3 외부 연결의 특성 이해하기
__5.4 Ingress 리소스를 통해 외부로 서비스 노출하기
____5.4.1 Ingress 리소스 생성하기
____5.4.2 Ingress를 통해 서비스 액세스하기
____5.4.3 동일한 Ingress를 통해 다수의 서비스 노출하기
____5.4.4 TLS 트래픽을 처리하기 위해 Ingress 설정하기
__5.5 포드가 연결을 수락할 준비가 되어 있을 때 신호 보내기
____5.5.1 준비 프로브 소개
____5.5.2 포드로 준비 프로브 추가하기
____5.5.3 실제환경에서 준비 프로브의 역할 이해하기
__5.6 각각의 포드를 찾기 위한 헤드리스 서비스 사용하기
____5.6.1 헤드리스 서비스 생성하기
____5.6.2 DNS를 통해 포드 발견하기
____5.6.3 모든 포드 발견하기(심지어 준비되지 않은 포드까지)
__5.7 서비스 문제 해결하기
__5.8 요약

6장. 볼륨: 컨테이너에 디스크 스토리지 연결
__6.1 볼륨 소개
____6.1.1 예제에서 볼륨 설명
____6.1.2 가능한 볼륨 유형 소개
__6.2 볼륨을 사용해 컨테이너 간에 데이터 공유하기
____6.2.1 emptyDir볼륨 사용하기
__6.3 워커노드 파일 시스템에 액세스하기
____6.3.1 hostPath 볼륨 소개
____6.3.2 hostPath 볼륨을 사용하는 시스템 포드 검사
__6.4 영구 스토리지 사용하기
____6.4.1 포드볼륨에서 GCE 영구 디스크 사용하기
____6.4.2 기본 영구 스토리지에서 다른 볼륨의 유형 사용하기
__6.5 기본 스토리지 기술에서 포드 분리하기
____6.5.1 PersistentVolumes(영구볼륨) 및PersistentVolumeClaims(영구볼륨클레임) 소개
____6.5.2 PersistentVolume 생성
____6.5.3 PersistentVolumeClaim을 생성해 PersistentVolume 할당하기
____6.5.4 포드에서 PersistentVolumeClaim 사용하기
____6.5.5 PersistentVolumes및 클레임 사용의 이점 이해하기
____6.5.6 PersistentVolumes재활용하기
__6.6 PersistentVolumes의 동적 프로비저닝
____6.6.1 스토리지 클래스리소스를 통해 사용 가능한 스토리지 유형 정의하기
____6.6.2 PersistentVolumeClaim의 스토리지 클래스 요청하기
____6.6.3 스토리지 클래스를 지정하지 않고 동적 프로비저닝하기
__6.7 요약

7장. ConfigMaps와 Secret: 애플리케이션 설정
__7.1 컨테이너화된 애플리케이션 설정
__7.2 컨테이너에 명령행 인자 전달
____7.2.1 도커에서 명령과 인자 정의하기
____7.2.2 쿠버네티스에서 명령과 인자를 재정의하기
__7.3 컨테이너를 위한 환경 변수 설정하기
____7.3.1 컨테이너 정의에 환경 변수 지정하기
____7.3.2 변수 값에서 다른 환경 변수 참조하기
____7.3.3 하드코딩된 환경 변수의 단점 이해하기
__7.4 ConfigMap을 통한 설정의 분리
____7.4.1 ConfigMaps 소개
____7.4.2 ConfigMap 생성하기
____7.4.3 컨테이너의 환경 변수로 ConfigMap 엔트리를 전달하기
____7.4.4 ConfigMap의 모든 항목을 한번에 환경 변수로 전달하기
____7.4.5 ConfigMap 항목을 명령행 인자로 전달하기
____7.4.6 ConfigMap 엔트리를 파일로 노출하기 위해 ConfigMap 볼륨 사용하기
____7.4.7 애플리케이션 다시 시작 없이 애플리케이션 설정 업데이트하기
__7.5 컨테이너에 민감한 데이터 전달을 위한 Secret 사용하기
____7.5.1 시크릿 소개
____7.5.2 기본 토큰 Secret 소개
____7.5.3 Secret 생성하기
____7.5.4 ConfigMaps와 Secret 비교하기
____7.5.5 포드에서 Secret 사용하기
____7.5.6 image pull Secrets 이해하기
__7.6 요약

8장. 애플리케이션에서 포드 메타데이터와 그 외의 리소스에 접근하기
__8.1 Downward API를 통한 메타데이터 전달하기
____8.1.1 사용 가능한 메타데이터 이해하기
____8.1.2 환경 변수를 통한 메타데이터 노출하기
____8.1.3 Downward API 볼륨 내의 파일을 통한 메타데이터 전달하기
__8.2 쿠버네티스 API 서버와 통신하기
____8.2.1 쿠버네티스 REST API 탐색하기
____8.2.2 포드 내에서 API 서버와 통신하기
____8.2.3 앰배서더 컨테이너와의 API 서버 통신 간소화
____8.2.4 클라이언트 라이브러리를 사용해 API 서버와 통신
__8.3 요약

9장. 디플로이먼트: 애플리케이션을 선언적으로 업데이트하기
__9.1 포드에서 실행 중인 애플리케이션 업데이트하기
____9.1.1 오래된 포드를 삭제하고 새로운 포드로 교체하기
____9.1.2 새로운 포드의 스핀 업 및 오래된 포드 삭제하기
__9.2 리플리케이션 컨트롤러를 통한 자동 롤링 업데이트 수행하기
____9.2.1 애플리케이션 초기 버전 실행
____9.2.2 kubectl을 통해 롤링 업데이트 수행하기
____9.2.3 kubectl 롤링 업데이트가 더 이상 사용되지 않는 이유 이해하기
__9.3 선언적으로 애플리케이션을 업데이트하기 위한 디플로이먼트 사용하기
____9.3.1 디플로이먼트 생성하기
____9.3.2 디플로이먼트 업데이트하기
____9.3.3 디플로이먼트 롤백하기
____9.3.4 롤아웃 속도 통제
____9.3.5 롤아웃 프로세스 일시 중지
____9.3.6 잘못된 버전의 롤아웃 방지
__9.4 요약

10장. 스테이트풀셋: 복제된 스테이트풀 애플리케이션 배포하기
__10.1 스테이트풀 포드 복제
____10.1.1 각각 분리된 저장소를 갖는 다수의 복제본 실행하기
____10.1.2 각 포드에 안정적인 ID 제공
__10.2 스테이트풀셋 이해하기
____10.2.1 스테이트풀셋과 레플리카셋 비교
____10.2.2 안정적인 네트워크 ID 제공
____10.2.3 각 스테이트풀 인스턴스에 안정적인 전용 스토리지 제공
____10.2.4 스테이트풀셋의 보장 이해하기
__10.3 스테이트풀셋 사용하기
____10.3.1 앱 및 컨테이너 이미지 만들기
____10.3.2 스테이트풀셋을 통한 애플리케이션 배포
____10.3.3 실제로 포드를 동작해보기
__10.4 스테이트풀셋에서 피어 발견
____10.4.1 DNS를 통한 피어 검색 구현
____10.4.2 스테이트풀셋 업데이트
____10.4.3 클러스터된 데이터 저장소 사용
__10.5 스테이트풀셋이 노드 장애를 처리하는 방법 이해하기
____10.5.1 네트워크에서 노드 연결 해제 시뮬레이션
____10.5.2 수동으로 포드 삭제
__10.6 요약


3부 BEYOND THE BASICS

11장. 쿠버네티스 내부 이해하기
__11.1 아키텍처 이해하기
____11.1.1 쿠버네티스 컴포넌트의 분산 특성(nature)
____11.1.2 쿠버네티스가 etcd 사용하는 방법
____11.1.3 API 서버가 하는 일
____11.1.4 API 서버가 클라이언트의 리소스 변화를 감지하는 방법 이해하기
____11.1.5 스케줄러 이해하기
____11.1.6 컨트롤러 매니저에서 실행되고 있는 컨트롤러 소개하기
____11.1.7 Kubelet이 하는 일
____11.1.8 쿠버네티스 서비스 프록시의 역할
____11.1.9 쿠버네티스 애드온 소개하기
____11.1.10 모두 함께 가져오기
__11.2 컨트롤러의 상호협력 방식
____11.2.1 관련된 컴포넌트 이해하기
____11.2.2 이벤트 체인
____11.2.3 클러스터 이벤트 관찰하기
__11.3 실행 중인 포드 이해하기
__11.4 상호 포드 네트워킹
____11.4.1 네트워크는 어떤 모습이어야 하는가
____11.4.2 네트워크의 동작 원리 깊이 알아보기
____11.4.3 컨테이너 네트워크 인터페이스 소개
__11.5 서비스의 구현 방식
____11.5.1 kube-proxy 소개하기
____11.5.2 kube-proxy가 iptables을 사용하는 방식
__11.6 고가용성 클러스터 실행
____11.6.1 앱의 가용성 높이기
____11.6.2 쿠버네티스 컨트롤 플레인 컴포넌트의 가용성 높이기
__11.7 요약

12장. 쿠버네티스 API 서버 보안
__12.1 인증 이해하기
____12.1.1 사용자와 그룹
____12.1.2 서비스어카운트 소개
____12.1.3 서비스어카운트 생성하기
____12.1.4 포드에 서비스어카운트 할당하기
__12.2 역할(롤)기반 접근 제어 클러스터 보안
____12.2.1 RBAC 인증 플러그인 소개
____12.2.2 RBAC 리소스 소개
____12.2.3 롤과 롤바인딩 사용하기
____12.2.4 클러스터롤과 클러스터롤바인딩 사용하기
____12.2.5 디폴트 클러스터롤과 클러스터롤바인딩 이해하기
____12.2.6 인증 권한을 현명하기 부여하기
__12.3 요약

13장. 클러스터 노드와 네트워크의 보안
__13.1 포드 내에서 호스트 노드의 네임스페이스 사용하기
____13.1.1 포드에서 노드의 네트워크 네임스페이스 사용하기
____13.1.2 호스트 네임스페이스를 사용하지 않고 호스트 포트에 바인딩
____13.1.3 노드의 PID와 IPC 네임스페이스 사용하기
__13.2 컨테이너 보안 컨텍스트 설정
____13.2.1 특정 사용자로 컨테이너 실행
____13.2.2 컨테이너가 루트로 실행하는 것을 방지하기
____13.2.3 권한 모드에서 포드 실행
____13.2.4 컨테이너에 개별 커널 기능 추가하기
____13.2.5 컨테이너에서 기능 제거
____13.2.6 프로세스가 컨테이너의 파일 시스템에 쓰는 것을 방지하기
____13.2.7 컨테이너가 다른 사용자로 실행될 때 볼륨 공유하기
__13.3 포드의 보안 관련 기능 사용 제한하기
____13.3.1 PodSecurityPolicy 리소스의 소개
____13.3.2 runAsUser, fsGroup, supplementalGroups 정책 이해하기
____13.3.3 허용, 기본 값, 허용하지 않음 설정하기
____13.3.4 포드가 사용할 수 있는 볼륨의 유형 제한하기
____13.3.5 다른 사용자 및 그룹에 다른 PodSecurityPolicies 할당
__13.4 포드 네트워크 분리
____13.4.1 네임스페이스에서 네트워크 격리 사용
____13.4.2 네임스페이스의 일부 포드만 서버 포드에 연결하도록 허용하기
____13.4.3 쿠버네티스 네임스페이스 간 네트워크 격리하기
____13.4.4 CIDR 표기법을 사용해 격리하기
____13.4.5 포드 세트의 아웃 바운드 트래픽 제한하기
__13.5 요약

14장. 포드의 계산 리소스 관리
__14.1 포드 컨테이너의 리소스 요청
____14.1.1 리소스 요청을 포함한 포드 만들기
____14.1.2 리소스 요청이 스케줄링에 미치는 영향 이해
____14.1.3 CPU 요청이 CPU 시간 공유에 미치는 영향 이해
____14.1.4 사용자 지정 리소스의 정의와 요청
__14.2 컨테이너에 사용 가능한 리소스 한계
____14.2.1 컨테이너가 사용 가능한 리소스 양에 대한 엄격한 한계 설정
____14.2.2 한계 초과
____14.2.3 컨테이너의 앱이 한계를 확인하는 방법 이해
__14.3 포드의 QoS 클래스 이해
____14.3.1 포드에 대한 QoS 클래스 정의
____14.3.2 메모리가 부족할 때 어떤 프로세스가 강제 종료되는지 이해하기
__14.4 네임스페이스당 포드에 대한 기본 요청 및 한계 설정
____14.4.1 LimitRange 리소스 소개
____14.4.2 LimitRange 객체 만들기
____14.4.3 한계 적용
____14.4.4 기본 리소스 요청 및 한계 적용
__14.5 네임스페이스에서 사용 가능한 총 리소스 한계
____14.5.1 ResourceQuota 객체 소개
____14.5.2 영구 스토리지에 할당량 지정
____14.5.3 생성 가능한 객체 수 제한
____14.5.4 특정 포드 상태 및 / 또는 QoS 클래스의 할당량 지정
__14.6 포드 리소스 사용 모니터링
____14.6.1 실제 리소스 사용량 수집 및 검색
____14.6.2 리소스 사용 통계의 히스토리 저장 및 분석
__14.7 요약

15장. 포드와 클러스터 노드의 오토스케일링
__15.1 포드의 수평적 오토 스케일링
____15.1.1 오토스케일링 프로세스 이해하기
____15.1.2 CPU 사용률에 따른 스케일링
____15.1.3 메모리 소비량에 기반한 스케일링
____15.1.4 기타 및 사용자 지정 메트릭을 기반으로 한 오토스케일링
____15.1.5 오토스케일링에 적합한 메트릭 항목 결정하기
____15.1.6 복제본을 0으로 스케일링다운
__15.2 포드의 수직적 오토 스케일링
____15.2.1 리소스 요청 자동으로 구성하기
____15.2.2 포드 실행 중 리소스 요청 수정하기
__15.3 클러스터 노드의 수평적 스케일링
____15.3.1 클러스터 오토스케일러 소개
____15.3.2 클러스터 오토스케일러 활성화
____15.3.3 클러스터 스케일다운 시 서비스 중단 제한하기
__15.4 요약

16장. 고급 스케줄링
__16.1 테인트와 톨러레이션을 사용해 특정 노드에서 포드 실행 제한하기
____16.1.1 테인트와 톨러레이션 소개
____16.1.2 노드에 사용자 정의 테인트 추가하기
____16.1.3 포드에 톨러레이션 추가하기
____16.1.4 테인트와 톨러레이션의 활용 방법 이해하기
__16.2 특정 노드로 포드를 유인하기 위해 노드 친밀성 사용하기
____16.2.1 하드 노드 친밀성 룰을 지정하기
____16.2.2 포드를 스케줄링할 때 노드의 우선순위 지정하기
__16.3 포드 친밀성 및 반친밀성으로 포드를 가깝게 위치하기
____16.3.1 인터포드 친밀성을 사용해 동일 노드에 포드 배포하기
____16.3.2 동일한 랙, 가용 영역 또는 지리적 위치에 포드 배포하기
____16.3.3 엄격한 요구 사항 대신 포드 친밀성 선호도 표현하기
____16.3.4 포드 반친밀성으로 포드를 서로 멀리해 스케줄링하기
__16.4 요약

17장. 애플리케이션 개발을 위한 베스트 프렉티스
__17.1 모든 것을 함께 가져오기
__17.2 포드의 라이프사이클 이해하기
____17.2.1 애플리케이션은 종료하고 재배치 해야 한다
____17.2.2 죽은 포드 또는 부분적으로 죽은 포드의 재스케줄링
____17.2.3 원하는 순서로 포드 시작하기
____17.2.4 라이프사이클 훅 추가하기
____17.2.5 포드 셧다운 이해하기
__17.3 모든 클라이언트 요청이 올바르게 처리되도록 보장하기
____17.3.1 포드가 시작할 때 클라이언트의 연결이 끊어짐을 방지하기
____17.3.2 포드 셧다운 동안 연결이 끊어짐을 방지하기
__17.4 쿠버네티스에서 애플리케이션을 쉽게 실행하고 관리할 수 있게 만들기
____17.4.1 관리 가능한 컨테이너 이미지 만들기
____17.4.2 이미지에 적절히 태그하고 imagePullPolicy를 현명하게 사용하기
____17.4.3 단일 차원 라벨 대신 다차원 라벨 사용하기
____17.4.4 주석을 통해 각 리소스 설명하기
____17.4.5 프로세스가 종료된 원인에 대한 정보 제공하기
____17.4.6 애플리케이션 로그 핸들링
__17.5 개발과 테스트의 Best Practice
____17.5.1 개발 과정에서 쿠버네티스 외부에서 애플리케이션 실행하기
____17.5.2 개발 중 미니큐브 사용하기
____17.5.3 버전 관리 및 리소스 매니페스트 자동 배포
____17.5.4 YAML / JSON 매니페스트를 작성하는 대안으로 Ksonnet을 소개
____17.5.5 CI(Continuous Integration) 및 CD(Continuous Delivery) 사용하기
__17.6 요약

18장. 쿠버네티스 확장하기
__18.1 사용자 지정 API 객체 정의하기
____18.1.1 CustomResourceDefinitions 소개
____18.1.2 사용자 지정 컨트롤러를 사용한 사용자 지정 리소스 자동화하기
____18.1.3 사용자 지정 객체 검증하기
____18.1.4 사용자 지정 객체에 사용자 지정 API 서버 제공
__18.2 쿠버네티스 서비스 카탈로그를 이용한 쿠버네티스 확장
____18.2.1 서비스 카탈로그 소개
____18.2.2 서비스 카탈로그 API 서버 및 컨트롤러 관리자 소개
____18.2.3 서비스 브로커 및 OpenServiceBroker API소개
____18.2.4 프로비저닝과 서비스 사용하기
____18.2.5 바인딩 해제와 프로비저닝 해제
____18.2.6 서비스 카탈로그 이해
__18.3 쿠버네티스 기반 플랫폼
____18.3.1 레드햇 오픈시프트 컨테이너 플랫폼7
____18.3.2 Deis 워크플로우와 Helm
__18.4 요약

__부록 A 다중 클러스터 환경에서 kubectl 사용하기
__부록 B kubeadm을 이용한 다중 노드 클러스터 설정
__부록 C 다른 컨테이너 런타임 사용하기
__부록 D 클러스터 페더레이션

★ 지은이의 말 ★

레드햇(Red Hat)에서 몇 년 근무하다가 2014년 말, 신설된 클라우드 인에이블먼트(Cloud Enablement) 팀에 배정됐다. 새 팀의 임무는 쿠버네티스상에서 개발된 회사의 미들웨어 제품을 오픈시프트 컨테이너 플랫폼(OpneShift Container Platform)으로 가져오는 것이었다. 그 당시 쿠버네티스는 정식으로 발표되지 않은 초기 버전(v1.0)이었다.
소프트웨어의 적절한 방향을 설정하고 쿠버네티스가 제공하는 기능을 이용하려면 쿠버네티스의 모든 기능을 신속하게 파악해야 했다. 문제가 발생했을 때, 우리가 일을 잘못한 건지 아니면 쿠버네티스 초기 버전의 버그인지를 구분해내기가 어려웠다.
그 후로 쿠버네티스도 눈부시게 발전했고 나도 쿠버네티스를 많이 이해하게 됐다. 나는 쿠버네티스라는 말조차 생경할 때 쿠버네티스를 사용하기 시작했다. 지금은 클라우드와 온프레미스 데이터 센터(on-premises datacenters)에서 애플리케이션을 실행하는 데 가장 빠르게 성장하고 가장 많이 사용되는 방법으로, 소프트웨어 엔지니어라면 모르는 사람이 없을 정도다.
쿠버네티스를 접한 지 한 달쯤 뒤에 오픈시프트/쿠버네티스(OpenShift/Kubernetes)에서 JBoss 와일드플라이(JBoss WildFly) 애플리케이션 서버 클러스터를 실행하는 방법을 두 개의 글로 작성해 블로그에 게시했다. 그 당시 간단한 블로그 포스트를 보고 매닝 출판사의 담당자가 쿠버네티스에 대한 책을 써달라고 연락할 것이라고는 상상도 못했다. 내가 아니더라도 책을 쓸만한 누군가에게 연락했을 그 제안을 거절하지 않았다.
그렇게 나는 이 책을 쓰게 됐다. 1년 반 넘게 글쓰기와 연구에 매진한 끝에 마침표를 찍었다. 이 여정은 굉장히 값진 경험이었다. 그저 사용자로서 배울 때보다 책을 쓰면서 기술에 관해 훨씬 더 자세히 알 수 있었다. 이 과정에서 쿠버네티스에 대한 지식이 확장됐고, 쿠버네티스 자체도 진화했으므로 이전에 썼던 내용을 고치고 다듬어야 했다. 나는 완벽주의자다. 이 책에 만족하지는 않는다. 그럼에도 MEAP 프로그램(Manning Early Access Program)의 수많은 독자가 이 책을 쿠버네티스를 향한 훌륭한 안내서로 평가해주셔서 기쁘다.
내 목표는 독자가 기술 자체를 이해하고 도구를 사용해 쿠버네티스 클러스터에 애플리케이션을 효율적으로 개발하고 배포할 수 있도록 가르치는 데 있다. 이 책은 실제로 적정한 수준의 가용성을 갖는 쿠버네티스 클러스터를 실제로 설정하거나 유지하는 것에 중점을 두지 않았다. 대신에 마지막 파트를 통해 독자가 그러한 클러스터의 구성이 어떻게 되는지 확실히 이해할 수 있게 작성했다. 그리고 이런 주제를 이해하기 쉬운 추가적인 리소스를 포함하고 있다.
쿠버네티스라는 굉장한 시스템을 통해 최대한의 결과를 얻는 방법을 알아가며 이 책을 즐겁게 읽어 나가길 바란다.

 

★ 옮긴이의 말 ★

네 명의 역자는 현재 IT전문회사 및 컨설팅회사에서 근무하며, 같은 회차 정보관리/컴퓨터시스템응용 기술사로 구성된 ‘108번역’이라는 소모임을 운영하고 있다. 최근 컨테이너 환경은 도커 엔진을 중심으로 쿠버네티스가 de-facto 표준이 되는 형국으로 변하고 있다. 마이크로서비스 환경으로 마이그레이션되는 최근 환경에서 수많은 도커를 유연하고 안정적으로 운영하기 위해서 고민하는 것은 당연하며 이에 오픈소스 프로젝트인 쿠버네티스가 그 답을 줄 것이다. 이 책은 애플리케이션 개발에 중점을 둔 개발자와 운영자 모두가 애플리케이션을 관리할 수 있는 관점에서 쓰여졌다. 무엇보다 쿠버네티스의 컴포넌트 각각에 대해 자세히 풀어 설명했으며 그림도 상세히 설명해 독자의 이해를 돕는다. 쿠버네티스에 대한 기본적인 이해부터 각각의 컴포넌트를 사용해 적용하는 법, 마지막으로 쿠버네티스 클러스터 내부까지 자세히 살펴보고 엔터프라이즈급 애플리케이션의 플랫폼까지 구축할 수 있도록 알려주고 있다. 이 책은 컨테이너 기반 오케스트레이션 플랫폼에 관심 있는 초급자뿐 아니라 실제 다양한 환경에 애플리케이션 배포를 원하는 중급 수준의 독자들에게 적합한 책이다. 이 책은 쿠버네티스 설치 및 운영에 필요한 다양한 정보를 제공하며 유연한 환경의 인프라를 구축할 수 있도록 가이드 해 줄 것이다.