1. Istio

역할 서비스 메쉬를 구성해 트래픽 관리, 보안, 모니터링, 트레이싱을 지원. 서비스 앞에 Envoy proxy(Sidecar) 를 주입해 네트워크 트래픽을 제어함. 세부 기능: Ingress Gateway: 외부 트래픽 진입점 VirtualService & DestinationRule: 트래픽 라우팅, 버전 분기 등 Telemetry: Envoy proxy가 Prometheus, OpenTelemetry로 메트릭 및 트레이싱을 수집함 Security: mTLS, 인증/인가, JWT 처리 등

2. OpenTelemetry Collector

역할 Istio/Envoy가 수집한 트레이싱 데이터(Span) 를 수신해서 다양한 백엔드로 전달. Jaeger, Zipkin, NewRelic, OTLP 등으로 멀티 백엔드 export가 가능. 세부 기능 receivers: 데이터를 수신 (예: OTLP, Zipkin) processors: 가공 및 필터링 (선택사항) exporters: 백엔드로 전달 (예: Jaeger, Prometheus Remote Write) service.pipelines: 위 구성들을 연결

3. Kiali

역할 Istio 서비스 메쉬의 시각화 도구. 실시간 트래픽 흐름, 라우팅 정책, 오류율, 성능 등을 볼 수 있음. 세부 기능 실시간 서비스 맵 요청 수, 지연 시간, 오류율 등 시각화 Istio 설정(VirtualService, DestinationRule 등) 검토 가능 서비스 간 의존성 확인 (디버깅에 매우 유용)

[구성]

1. 기본 Istio 환경 구축 + 샘플 앱 배포

# brew로 istioctl 설치
brew install istioctl

# istioctl 버전 확인을 진행하여 설치 확인
istioctl version

# Istio demo 프로파일로 설치
# → Prometheus, Kiali, Jaeger, Grafana 포함
istioctl install --set profile=demo -y
# Tech CS 분들은 여기서 오류 발생 가능! VPN 연결 후 재시도해 보세요

# 카카오클라우드로 진행 시 failed to call Webhook 발생
# https://kko.kakao.com/NwPwmdCDcA
# deploy 전체 spec 설정이 아닌 pod spec 설정에서 수정해 주세요.
kubectl edit deployment -n istio-system istiod
#***
#spec:
#    hostNetwork: true # 추가
#    dnsPolicy: ClusterFirstWithHostNet
#containers:
#***

# default 네임스페이스에 istio-injection label 추가
kubectl label namespace default istio-injection=enabled

# Bookinfo 샘플 앱 배포
kubectl apply -f https://raw.githubusercontent.com/istio/istio/release-1.21/samples/bookinfo/platform/kube/bookinfo.yaml

# Gateway + 트래픽 라우팅 정의 적용
kubectl apply -f https://raw.githubusercontent.com/istio/istio/release-1.21/samples/bookinfo/networking/bookinfo-gateway.yaml

# Istio Ingress Gateway의 EXTERNAL-IP 확인
# 주소 확인 후 웹브라우저에서 접속
kubectl get svc istio-ingressgateway -n istio-system
# 예: http://<EXTERNAL-IP>/productpage

NGINX Ingress Controller는 "단순한 출입문", Istio + Ingress Gateway는 "보안·관제·스마트 제어까지 가능한 첨단 통제소"

2. Kiali, Prometheus, Grafana로 메트릭 시각화

Prometheus : Istio에서 수집한 메트릭 데이터를 저장 Grafana : Prometheus 데이터를 시각화 (대시보드) Kiali : Istio 메시에 연결된 서비스 간 관계/트래픽 흐름 시각화

# observability 네임스페이스 생성 (선택)
kubectl create namespace observability
# 필요 시 생성하고, 아래의 파드 생성 시 선택적으로 네임스페이스 변경하여 진행.
# 기본적으로 istio-system 네임스페이스에 생성됨. 변경하는 법은 따로 기재하지 않음.

# Istio에서 제공하는 애드온 매니페스트 적용
# Prometheus, Grafana, Kiali 포함
# istio-system 네임스페이스에 관련 Pod들을 배포
# prometheus는 이미 설치되어 있을 수 있음!
kubectl apply -f https://raw.githubusercontent.com/istio/istio/release-1.18/samples/addons/prometheus.yaml
kubectl apply -f https://raw.githubusercontent.com/istio/istio/release-1.18/samples/addons/grafana.yaml
kubectl apply -f https://raw.githubusercontent.com/istio/istio/release-1.18/samples/addons/kiali.yaml

# 모두 running 되고 있는지 확인
kubectl get pods -n istio-system

# 접근 테스트 (포트포워딩)
# 내부 서비스이기에 서비스화 시키지 않고 포트포워딩 하여 사용합니다!
# 이는 비슷한 구성은 카카오클라우드 grafana 기술문서에도 나와있습니다.

# Kiali (서비스 맵 보기)
# http://localhost:20001
kubectl port-forward svc/kiali -n istio-system 20001:20001
# Grafana (대시보드)
# http://localhost:3000
kubectl port-forward svc/grafana -n istio-system 3000:3000
# Prometheus (메트릭 확인)
# http://localhost:9090
kubectl port-forward svc/prometheus -n istio-system 9090:9090

3. 트레이스 추적

OpenTelemetry Collector : Istio에서 수집한 trace 데이터를 수집/가공/전송 Jaeger : 트레이스 데이터를 저장하고 시각화하는 UI 제공 Istio : Envoy 사이드카에서 trace 생성, OpenTelemetry에 전달

# Jaeger 배포
kubectl apply -f https://raw.githubusercontent.com/istio/istio/release-1.18/samples/addons/jaeger.yaml

# OpenTelemetry Collector 배포
# 이 구성은 OpenTelemetry Collector가 4317 포트로 OTLP 데이터를 수신하고, 
# 수신한 트레이스를 Jaeger에 전달하도록 설정되어 있음
kubectl apply -f https://raw.githubusercontent.com/istio/istio/release-1.18/samples/addons/extras/opentelemetry.yaml

# 포트포워딩으로 UI 확인
# http://localhost:16686
kubectl port-forward svc/jaeger -n istio-system 16686:16686

# 테스트 명령어 -> 몇번 실행 후 Jaeger UI에서 서비스 간 호출 경로, 요청 지연 시간 등 확인 가능
kubectl exec "$(kubectl get pod -l app=productpage -o jsonpath={.items..metadata.name})" \
    -c productpage -- curl -s http://localhost:9080/productpage

(참고)

• https://blog.serialexperiments.co.uk/posts/kubernetes-port-forward-already-in-use/
• https://nginxstore.com/blog/istio/istio-prometheus-%EB%A9%94%ED%8A%B8%EB%A6%AD-%EC%88%98%EC%A7%91-%EB%B0%8F-grafana-%EC%97%B0%EB%8F%99/
• https://istio.io/latest/docs/ops/integrations/jaeger/#installation
• https://istio.io/latest/docs/tasks/observability/distributed-tracing/opentelemetry/
• https://velog.io/@rudclthe/istio-kiali

1. 환경 세팅

VM 3대를 준비 (master 1 + worker 2) Offline 환경을 구성하기 위해 Outbound정책 Port에 제한을 둠

(단, KIC 환경에서는 VM 생성 시 아웃바운드 정책 Port를 모두 열고 VM생성이 끝나면 SG를 변경해 줄 것)

6443 - api server 2379 - etcd 2380 - etcd 4443 - metric server 179 - calico 10250 - kubelet API

2. Docker 설치

2.1 Docker 설치에 필요한 패키지를 준비

URL을 통해 받거나 Docker가 설치되어 있는 VM에서 구해도 됨 

focal 은 ubuntu 20.xx bionic 은 ubuntu 18.xx URL : https://download.docker.com/linux/ubuntu/dists/bionic/pool/stable/amd64/

VM 경로 : /var/cache/apt/archives 확인

필요 패키지 - yohan guide (버전을 맞추어 설치) containerd~ docker-ce-cli~ docker-ce-rootless-extra~ docker-ce~ docker-compose~ docker-scan-plugin~ libltdl~ pigz~

(본 테스트에서는 containerd, docker-ce, docker-cli 로만 구성)

2.2 scp 를 통한 패키지 이동

로컬에서 패키지를 받았으면 로컬 → GateWay(oliver) → offline vm 으로 이동 통신가능한 VM에서 패키지를 받았으면 online vm → GateWay(oliver) → offline vm 으로 이동

2.3 dpkg 를 통한 설치

.deb가 있는 디렉토리에서 dpkg 를 통한 패키지 설치

$ sudo dpkg -i *.deb

Trouble Shooting❗️

• containerd 버전문제로 1.4.1 이상으로 해결

dpkg: error processing package docker-ce (–install): dependency problems - leaving unconfigured

의존성 트러블은 패키지가 부족하면 수도 없이 나옴

2.4 docker 설정 및 croup 변경

2.4.1 docker 설정 (선택적)

$ sudo usermod -aG docker $USER 
$ 재시작 하면 적용
사용자 그룹을 추가한다면 sudo 를 안붙여도 됨

2.4.2 cgroup 변경

cat <<EOF | sudo tee /etc/docker/daemon.json
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF

$ sudo systemctl daemon-reload
$ sudo systemctl restart docker

2.5 Docker 설치 확인

3. K8S 설치 

kube-apiserver 는 최대 1단계의 마이너 버전 차이까지 가능 ex) 하나의 kube-apiserver 의 버전이 1.21 라면 다른 kube-apiserver 는 1.20 or 1.21 이여야 함

kubelet 은 kube-apiserver 보다 최신이여서는 안됨 그리고 최대 2단계 이전의 마이너 버전 차이까지 가능 ex) kube-apiserver 가 1.21 이라면 kubelet 은 1.21 or 1.20 or 1.19 까지 사용가능

kubectl 은 kube-apiserver 과 최대 1단계의 마이너 버전 차이까지 가능 ex) kube-apiserver 가 1.21 이라면 kubectl 은 1.22 or 1.21 or 1.20 까지 사용가능

3.1 환경 설정

필요한 패키지파일과 이미지 파일을 준비 패키지 파일은 2.1 과 동일하게 구할 수 있음 이미지의 경우 docker save로 .tar 저장

필요 패키지 kubeadm~ kubectl~ kubelet~ kubernetes-cni~ conntrack~ cri-tools~ socat~

필요 이미지 kube-proxy kube-apiserver kube-controller-manager kube-scheduler etcd coredns pause calico/cni                           (CNI 설치 시 사용) calico/node                       (CNI 설치 시 사용) calico/kube-controllers   (CNI 설치 시 사용)

3.2 K8S 설치 (master node)

3.2.1 설치

준비한 이미지 파일을 docker load 로 이미지 업로드  준비한 패키지 파일을 dpkg 로 설치

$ sudo dpkg -i *.deb

3.2.2 설정

$ sudo swapoff -a
$ sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
$ sudo kubeadm init

(master node)
$ mkdir -p $HOME/.kube
$ sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
$ sudo chown $(id -u):$(id -g) $HOME/.kube/config

(확인)
$ kubectl get nodes 

CNI 가 미설치 되어 NotReady 확인 가능

3.3 CNI 설치

calico 를 사용 앞 서 준비한 calico 이미지 사용 https://projectcalico.docs.tigera.io/manifests/calico.yaml 의 셀스크립트를 calico.yaml 파일 저장

$ kubectl apply -f calico.yaml

(확인)
$ kubectl get all -A
$ kubectl get nodes

3.4 worker node 구축

2.docker 설치와 3.k8s설치 내용대로 설치 (단, init 하지말 것) worker node의 k8s 설치에 사용 했던 이미지

kube-proxy coredns pause calico/cni (CNI 설치 시 사용) calico/node (CNI 설치 시 사용)

(worker node)
master node 에서 init 했을 때 받은 토큰으로 조인
$ sudo kubeadm join 172.30.3.97:6443 --token gdpgce.j5mvth8gt7qu4u86 \
--discovery-token-ca-cert-hash sha256:ed4b205d09552dc4c957fb0e08c962560af5c9c93b0e3f222dfd7e29af7796e0 

(master node 에서 확인)
$ kubectl get all -A
$ kubectl get nodes

3.5 k8s 설치 결과

4. k8s Multi Master 구성

4.1 VM 세팅

앞선 Docker & K8S offline install을 통해 master node 1대, worker node 2대가 구성이 되어 있을 것 (재사용) 같은 방법으로 master node 2대 추가, 기존의 node들은 kubeadm reset 처리 총, master node 3대 worker node 2대를 연결예정

4.2 Main Master Token 얻기

$ sudo kubeadm init --token-ttl 0 --control-plane-endpoint "[Loadbalancer IP]:6443" --upload-certs --pod-network-cidr=192.168.50.0/24 >> kubeadm-init-result.txt

(pod network cidr 를 지정하지 않으면 추 후 조인 시에 중복으로 인해 에러발생할 수 있음)

빨간 상자= control-plane token 노란 상자 = worker token

4.3 각 노드 별 필요한 Token으로 Join

( Controll-plane Node ) 4.1 VM 세팅이 끝난 후 kubeadm init 대신 Controll-plane Token 값 적용 (위 빨간 상자 확인)

(Worker Node) 4.1 VM 세팅이 끝난 후 Worker Token 값 적용 (위 노란 상자 확인)

4.4 연결 확인

Master node에서 확인

$ kubectl get all -A
$ kubectl get nodes

Main Master 에서만 kubectl apply -f calico.yaml 하면 됨 ( Sub Master 에서 실행 X ) 각 Node 들은 필요 이미지만 들고 있으면 됨

(참고) Docker 참고 주소

• get.docker.com
• https://choco-life.tistory.com/40
• https://docs.cyberwatch.fr/deploy/en/2_deploy_cyberwatch/offline/swarm/install_docker.html

K8S 참고 주소

• https://velog.io/@seokbin/Kubernetes-%ED%81%B4%EB%9F%AC%EC%8A%A4%ED%84%B0-%EC%84%A4%EC%B9%98-kubeadm-offline-%ED%99%98%EA%B2%BD
• https://github.com/tmax-cloud/install-k8s
• https://docs.genesys.com/Documentation/GCXI/latest/Dep/DockerOffline
• https://www.sobyte.net/post/2022-06/k8s-intranet/
• https://www.centlinux.com/2019/04/install-kubernetes-k8s-offline-on-centos-7.html

Ceph Storage Cluster는 안정적이며, 높은 성능과 Block, File, Object 스토리지로 다양하게 사용이 가능합니다. Kubernetes Cluster내에 Ceph Storage Cluster를 구성하여 이를 PVC로 사용하는 테스트 입니다.

k8s 구성 환경

k8s node 1 : 8vCPU / 32 GiB Memory / 볼륨 100GB + 50GB k8s node 2 : 8vCPU / 32 GiB Memory / 볼륨 100GB + 50GB k8s node 3 : 8vCPU / 32 GiB Memory / 볼륨 100GB + 50GB k8s node 4 : 8vCPU / 32 GiB Memory / 볼륨 100GB + 50GB Ceph 클러스터를 위해 2개의 MGR / 3개의 MON / 디스크 수만큼의 OSD 데몬이 실행되어야 합니다.

1. Rook 예제 및 소스파일 다운로드

Rook 예제 파일은 거의 모든 환경에서 대응할 수 있는 예제코드를 제공

$ git clone https://github.com/rook/rook.git/

2. helm 활용 rook 오퍼레이터 구성

helm 으로 간단하게 rook-ceph 구성

(repo 추가) 
$ helm repo add rook-release https://charts.rook.io/release 
$ helm search repo rook-ceph 

(rook 오퍼레이터 설치) 
$ kubectl create namespace rook-ceph 
(repo 추가) 
$ helm install --namespace rook-ceph rook-ceph rook-release/rook-ceph 
$ kubectl get all -n rook-ceph

3. Ceph 클러스터 구성

기본으로 구성할 경우, 2개의 MGR / 3개의 MON / 빈디스크 수만큼의 OSD 데몬이 생성되며 최소 3개 노드이상일 경우 기본구성으로 설치하면 적당함

아래 설치하기 전에 위에 구성한 오퍼레이터가 꼭 동작하고 있어야 하며, 만약 오퍼레이터가 설치 중이라면 설치완료 후 진행

$ helm install --namespace rook-ceph rook-ceph-cluster --set operatorNamespace=rook-ceph rook-release/rook-ceph-cluster 
$ kubectl get all -n rook-ceph

Trouble Shooting❗️

rook-ceph-osd-prepare-[host명] 파드는 Completed 되었으나 정작 osd 파드가 생성되지 않음

kubectl -n rook-ceph logs <ceph-osd-prepare-pod>

를 통해 로그 확인 시 'cephosd: skipping OSD configuration as no devices matched the storage settings for this nod' 가 발생하는 것을 확인

각 노드별 볼륨을 추가하여 해결

4. Toolbox 설치

rook/deploy/examples/ 에 toolbox.yaml 파일을 사용하여 구성 toolbox를 통해 ceph cli를 사용할 수 있음

$ kubectl apply -f toolbox.yaml 
$ kubectl get deploy rook-ceph-tools -n rook-ceph 
$ kubectl -n rook-ceph exec -it 
(kubectl -n rook-ceph get pod -l "app=rook-ceph-tools" -o jsonpath='{.items[0].metadata.name}') bash 
(toolbox)$ ceph -s 
(toolbox)$ ceph osd status

5. Dashboard 사용

CephCluster의 Dashboard 서비스를 ssl을 사용하지 않도록 변경하고, 기본 url을 변경

$ kubectl get svc -n rook-ceph 
$ kubectl edit CephCluster rook-ceph -n rook-ceph 
(수정전) 
dashboard : 
  enabled : true 
  ssl : true 

(수정후) 
dashboard : 
  enabled : true 
  ssl : false 
  urlPrefix : /ceph-dashboard

대시보드가 ssl을 사용한다면 8443 포트이지만, ssl을 사용하지 않도록 구성하니 7000 포트로 고정 rook-ceph 예제파일 중 dashboard-loadbalancer.yaml 파일을 수정하고 적용

$ vi dashboard-loadbalancer.yaml 
(수정전) 
port : 8443 
targetPort : 8443 

(수정후) 
port : 7000 
targetPort : 7000 

$ kubectl apply -f dashboard-loadbalancer.yaml

이제 rook-ceph-mgr-dashboard-loadbalancer라는 서비스가 LoadBalancer 타입으로 만들어지고 외부 IP가 확인됨 (본 테스트에서는 카카오클라우드 LB를 사용하여 접속)

브라우저에서 http://PublicIP:7000/ceph-dashboard/ 경로로 접속 계정은 admin이고 패스워드는 아래 명령으로 확인할 수 있음

# 패스워드 확인 
$ kubectl get secret rook-ceph-dashboard-password -n rook-ceph -o yaml | grep "password:" | awk '{print $2}' | base64 --decode

(아래 접속 화면은 pvc 생성 후 캡처)

6. (Ceph-filesystem) PVC 생성

PVC를 생성하면 자동으로 PV도 함께 생성되고 연결됨

$ vi cephfs-pvc01.yaml 
--- 
apiVersion : v1
kind : PersistentVolumeClaim
metadata :
  name : cephfs-pvc01
spec :
  accessModes :
    - ReadWriteMany
  resources :
    requests :
      storage : 1Gi
  storageClassName : ceph-filesystem

$ kubectl apply -f cephfs-pvc01.yaml 
$ kubectl get pvc  

7. (ceph-block) PVC 생성

CephFS와 가장 큰 차이점은 PVC 생성 시 accessModes값을 ReadWriteOnce로 구성 RBD는 ReadWriteMany로 구성할 수 없음

$ vi cephblock-pvc01.yaml 
---
apiVersion : v1
kind : PersistentVolumeClaim
metadata :
  name : rbd-pvc
spec :
  accessModes :
    - ReadWriteOnce
  resources :
    requests :
      storage : 10Gi
  storageClassName : ceph-block

$ kubectl apply -f cephblock-pvc01.yaml 
$ kubectl get pvc

8. Test pod 생성 및 확인

pod를 만들어 마운트가 되는지 테스트

$ vi ceph-test-pod.yaml 
---
apiVersion: v1
kind: Pod
metadata:
  name: ceph-test-pod
spec:
  containers:
    - name: web-server
      image: nginx
      volumeMounts:
        - name: ceph-filesystem-01
          mountPath: /data1
        - name: ceph-block-01
          mountPath: /data2
  volumes:
    - name: ceph-filesystem-01
      persistentVolumeClaim:
        claimName: cephfs-pvc01
        readOnly: false
    - name: ceph-block-01
      persistentVolumeClaim:
        claimName: rbd-pvc
        readOnly: false

$ kubectl apply -f ceph-test-pod.yaml

(확인)                    
$ kubectl exec -ti ceph-test-pod /bin/bash                    
rdb-test-pod01>df -h

설정한 마운트 설정에 맞게 마운트가 된 것을 볼 수 있음

(참고)

• https://itmaya.co.kr/wboard/view.php?wb=tech&idx=35
• https://jay-chamber.tistory.com/entry/rook-ceph-trouble-shooting-OSD%EA%B0%80-%EC%83%9D%EC%84%B1%EB%90%98%EC%A7%80-%EC%95%8A%EC%95%84%EC%9A%94-Try-1
• https://rook.io/docs/rook/v1.9/ceph-teardown.html#zapping-devices
• 24단계 실습으로 끝내는 쿠버네티스(Rook-ceph) https://naver.me/I55O7bmc
• https://computing-jhson.tistory.com/112

Cloud Infra ochestration : Tool 구성을 aws로 진행

1. 프로젝트 개요

1-1. WorkFlow

1-2. 기술스택과 도구

|스택 및 도구| |:-:|:-:| |jenkins| |Ansible| |Terraform| |Docker| |Kubernetes| |Git|

2. 프로젝트 구성

초기 Architecture 설계도

네트워크|IPv4 CIDR |:--:|:--:| VPC|10.0.0.0/16 public subnet|10.0.10.0/24 private subnet|10.0.30.0/24

3. CI/CD를 위한 기본 인프라 구성

3-1. Kubernetes Cluster 구성

|kubeadm|kubelet|kubectl |:--:|:--:|:--:|:--:| 버전|1.22.8|1.22.8|1.22.8

구성|설정값 |:--:|:--:| 설치방법|Kubeadm pod-network-cidr|172.16.0.0/16

3-2. Build 및 Deployment Server(Jenkins, Ansible, Docker) 구성

3-2-1) 기본 terraform 구성

vi provider.tf : Infrastructure의 type

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 3.0"
    }
  }
}

provider "aws" {
  region = "ap-northeast-2"
}

vi vpc.tf : 가용영역1개, public2개, private1개 생성

module "project1_vpc" {
  source = "terraform-aws-modules/vpc/aws"

  name = "project1_vpc"

  cidr = "10.0.0.0/16"

  azs             = ["ap-northeast-2a"]
  public_subnets  = ["10.0.10.0/24", "10.0.20.0/24"]
  private_subnets = ["10.0.30.0/24"]

  create_database_subnet_group = true

  create_igw = true

  enable_nat_gateway = true
  single_nat_gateway = true

}

vi ec2.tf : 4대의 ec2 생성

resource "aws_key_pair" "project1_key" {
  key_name   = "project1_key"
  public_key = file("/home/vagrant/.ssh/id_rsa.pub")
}

resource "aws_instance" "jenkins" {
  ami                    = "ami-058165de3b7202099"
  availability_zone      = module.project1_vpc.azs[0]
  instance_type          = "t2.medium"
  vpc_security_group_ids = [aws_security_group.all-sg.id]
  subnet_id              = module.project1_vpc.public_subnets[0]
  key_name               = aws_key_pair.project1_key.key_name

  tags = {
    Name = "jenkins"
  }
}


resource "aws_instance" "ansible" {
  ami                    = "ami-058165de3b7202099"
  availability_zone      = module.project1_vpc.azs[0]
  instance_type          = "t2.micro"
  vpc_security_group_ids = [aws_security_group.all-sg.id]
  subnet_id              = module.project1_vpc.public_subnets[0]
  key_name               = aws_key_pair.project1_key.key_name

  tags = {
    Name = "ansible"
  }
}

resource "aws_instance" "docker" {
  ami                    = "ami-058165de3b7202099"
  availability_zone      = module.project1_vpc.azs[0]
  instance_type          = "t2.micro"
  vpc_security_group_ids = [aws_security_group.all-sg.id]
  subnet_id              = module.project1_vpc.public_subnets[0]
  key_name               = aws_key_pair.project1_key.key_name

  tags = {
    Name = "docker"
  }
}


resource "aws_instance" "k8s" {
  ami                    = "ami-058165de3b7202099"
  availability_zone      = module.project1_vpc.azs[0]
  instance_type          = "t2.medium"
  vpc_security_group_ids = [aws_security_group.all-sg.id]
  subnet_id              = module.project1_vpc.public_subnets[0]
  key_name               = aws_key_pair.project1_key.key_name

  tags = {
    Name = "k8s"
  }
}

vi sg.tf : 모든 port를 열어 놓음

resource "aws_security_group" "all-sg" {
  name        = "all-sg"
  description = "Allow all "
  vpc_id      = module.project1_vpc.vpc_id

  ingress {
    cidr_blocks = ["0.0.0.0/0"]
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
  }

  egress {
    cidr_blocks = ["0.0.0.0/0"]
    from_port   = 0
    protocol    = "-1"
    to_port     = 0
  }
}

3-2-2) Ansible구성

• bastionhost -- hosts.ini -- playbook ㄴ installJenkins.yml ㄴ installDoker.yaml ㄴ installk8s.yaml
  

3-2-3) Jenkins build

- hosts: jenkins_host

  tasks:
    - shell: sudo apt-get update
      ignore_errors: yes
    - shell: sudo apt install -y openjdk-11-jdk
    - shell: curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo tee /usr/share/keyrings/jenkins-keyring.asc > /dev/null
    - shell: echo "deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] https://pkg.jenkins.io/debian-stable binary/" | sudo tee /etc/apt/sources.list.d/jenkins.list > /dev/null
    - shell: sudo apt-get update
      ignore_errors: yes
    - command: apt install -y fontconfig jenkins
    - command: apt install -y maven

3-2-4) Docker build

- name: Docker VM Provisioning
  hosts: docker_host
  gather_facts: false

  tasks:
    - command: apt update
      # 사용 가능한 패키지와 그 버전 리스트 업데이트

    - command: apt install -y ca-certificates curl gnupg lsb-release
      # docker 설치

    - command: apt install -y python3-pip
      # python3용 pip 설치 및 python 모듈 구축에 필요한 모든 종속성 설치

    - shell: curl https://get.docker.com | sh
      # docker 설치

    - shell: usermod -aG docker ubuntu
      ubuntu 사용자를 doker 그룹에 추가

    - pip:
        name:
          - docker
          - docker-compose
          # pip를 사용한 docker, docker-compose 설치

3-2-5) ansible build

- name: Ansible VM Provisioning
  hosts: ansible_host
  gather_facts: false

  tasks:
    - command: apt update
    - command: apt install -y ca-certificates curl gnupg lsb-release
    - command: apt install -y python3-pip
    - shell: curl https://get.docker.com | sh
    - shell: usermod -aG docker ubuntu
    - pip:
        name:
          - docker
          - docker-compose
    - command: apt install -y ansible
    - command: apt install -y python3-pip
    - shell: sed -i 's/PasswordAuthentication no/PasswordAuthentication yes/g' /etc/ssh/sshd_config
    - shell: pip install openshift==0.11
    - shell: echo 'ubuntu:ubuntu' | chpasswd
    - shell: sudo systemctl restart ssh
    - shell: mkdir /home/ubuntu/.kube
    - shell: curl -LO https://dl.k8s.io/release/v1.22.8/bin/linux/amd64/kubectl
    - shell: sudo install kubectl /usr/local/bin/
   #- shell: scp ~/.kube/config .kube/config

3-2-6) k8s build

- name: Contorl-Plane VM Provisioning
  hosts: controlplane_host
  gather_facts: false

  tasks:
    - command: apt update
    - command: apt install -y ca-certificates curl gnupg lsb-release
    - command: apt install -y python3-pip
    - shell: curl https://get.docker.com | sh
    - shell: usermod -aG docker ubuntu
    - pip:
        name:
          - docker
          - docker-compose
    - command: apt-get install -y apt-transport-https ca-certificates curl
    - shell: curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
    - shell: echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
    - command: apt-get update
    - shell: sudo apt-get install kubeadm=1.22.8-00 kubelet=1.22.8-00 kubectl=1.22.8-00 -y
    - copy:
        src: "/home/ubuntu/daemon.json"
        dest: "/etc/docker/"
    - shell: sudo systemctl restart docker
    - shell: sudo systemctl daemon-reload && sudo systemctl restart kubelet
    - shell: IPADDR=`ip addr | tail -n 8 | head -n 1 | cut -f 6 -d' ' | cut -f 1 -d '/'`
    - shell: sudo kubeadm init --control-plane-endpoint "{{ lookup('env', 'IPADDR') }}" --pod-network-cidr 172.16.0.0/16 --apiserver-advertise-address "{{ lookup('env', 'IPADDR') }}"
    - shell: mkdir -p /home/ubuntu/.kube
    - shell: sudo cp -i /etc/kubernetes/admin.conf /home/ubuntu/.kube/config
    - shell: sudo chown ubuntu:ubuntu /home/ubuntu/.kube/config
    - fetch:
        src: "/home/ubuntu/.kube/config"
        dest: "/home/ubuntu/.kube/config"
        flat: yes
   #- shell: kubectl create -f https://projectcalico.docs.tigera.io/manifests/tigera-operator.yaml
    - shell: curl https://projectcalico.docs.tigera.io/manifests/custom-resources.yaml -O
    - replace:
        path: /home/ubuntu/custom-resources.yaml
        regexp: 192.168
        replace: 172.16
   #- shell: kubectl create -f custom-resources.yaml

3-2-6) worker node build

- name: Contorl-Plane VM Provisioning
  hosts: controlplane_host
  gather_facts: false

  tasks:
    - command: apt update
    - command: apt install -y ca-certificates curl gnupg lsb-release
    - command: apt install -y python3-pip
    - shell: curl https://get.docker.com | sh
    - shell: usermod -aG docker ubuntu
    - pip:
        name:
          - docker
          - docker-compose
    - command: apt-get install -y apt-transport-https ca-certificates curl
    - shell: curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
    - shell: echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
    - command: apt-get update
    - shell: sudo apt-get install kubeadm=1.22.8-00 kubelet=1.22.8-00 kubectl=1.22.8-00 -y
    - copy:
        src: "/home/ubuntu/daemon.json"
        dest: "/etc/docker/"
    - shell: sudo systemctl restart docker
    - shell: sudo systemctl daemon-reload && sudo systemctl restart kubelet

#! /bin/sh
sudo kubeadm join 10.0.10.248:6443 --token u3adz9.flbop6nslkaupqrq --discovery-token-ca-cert-hash sha256:70f23d516ea80a39c784d129bddb13d6f71a96865b97acac573054443183b355

4. ci/cd 구현

4-1. Kubernetes Cluster Pod 배포를 위한 Ansible Playbook

4-1-1) kubernetes playbook

vi docker_build_and_push.yaml : DockerHub에서 image build 및 push

- name: Docker Image Build and Push
  hosts: docker_host
  gather_facts: false

  tasks:
    - command: docker image build -t repush/cicdproject:"{{ lookup('env', 'BUILD_NUMBER') }}" ~/
    - command: docker login -u repush -p "{{ lookup('env', 'TOKEN') }}"
    - command: docker push repush/cicdproject:"{{ lookup('env', 'BUILD_NUMBER') }}"
    - command: docker logout

• 첫번째 command: image build command, 변수를 통해 버전을 지정 (중복이 되지 않도록 build 횟수로 버전 생성)
• 두번째 command: DockerHub login command, 변수를 통해 Token을 지정
• 세번째 command: push command, 변수를 통해 버전을 지정 (중복이 되지 않도록 build 횟수로 버전 생성)
• 네번째 command: logout command
  
  

vi kube_deploy.yaml : k8s deployment 및 service

- hosts: ansible_host
  gather_facts: no

  tasks:
    #- command: kubectl apply -f java-hello-world/kube_manifest/
    - name: Create Deployment                        # container 배포
      k8s:
        state: present
        definition:
          apiVersion: apps/v1
          kind: Deployment
          metadata:
            name: java-hello
            namespace: default
          spec:
            replicas: 6                              # pod 개수 지정
            selector:
              matchLabels:
                app: java-hello
            template:
              metadata:
                labels:
                  app: java-hello
              spec:
                containers:
                  - name: java-hello
                    image: "repush/cicdproject:{{ lookup('env', 'BUILD_NUMBER') }}"       # DockerHub에 push된 image 
                    imagePullPolicy: Always
                    ports:
                      - containerPort: 8080           # containerPort지정
    - name: Create Service                            # service 배포
      k8s:
        state: present
        definition:
          apiVersion: v1
          kind: Service
          metadata:
            name: java-hello-svc
            namespace: default
          spec:
            type: NodePort
            selector:
              app: java-hello
            ports:
              - port: 80
                targetPort: 8080
                nodePort: 31313                        # nodePort 지정

4-2. Docker Image Build를 위한 이미지용 Dockerfile

4-2-1) Dockerfile

vi Dockerfile

FROM tomcat:9.0-jre11-openjdk                # tomcat:9.0-jre11-openjdk 이미지를 가져옴

COPY webapp.war /usr/local/tomcat/webapps    # 현재 경로의 war파일을 이미지 안에 /usr/local/tomcat/ 경로에 복사

4-3. ci/cd 구현을 위한 Jenkins Job 구성

4-3-1) 사용된 플러그인

• Maven Integration plugin 3.19
• Maven Invoker plugin 2.4
• Publish Over SSH 1.24

4-3-2) JAVA Project Build를 위한 JDK환경변수 세팅

Jenkins 관리 - Global Tool Configuration - JDK

4-3-3) JAVA Project Build를 위한 Maven환경변수 세팅

Jenkins 관리 - Global Tool Configuration - Maven

4-3-4) ci/cd 구현을 위한 Junkins Job 설정

새로운 Item - Pipeline

1) DockerHub 로그인을 위한 로그인 토큰 설정

General

• Default Value: DockerHub 계정의 Token

2) 프로젝트의 브랜치 변화 감지를 위한 Build Triggers 설정

Build Triggers

• 매 분마다 Github의 Push Event감지하는 Polling설정

3) Pipeline과 Jenkins파일 구성

Pipiline - Definition - SCM

Pipiline - Definition - Script Path

• Github Repository 내의 jenkinsfile 상대경로

Jenkinsfile 구성

• Java Build stage: Maven을 통해 Java Project Archive파일 빌드
• Docekr Image Build With Remote Ansible Server AND Remote Docker Server Using Publish Over SSH Module: Publish Over SSH Module모듈로 Docker Image 빌드를 위한 파일을 Ansible서버에 전송 후 Docker서버에 전송, Ansible 서버에 Docker Image 빌드와 Project 배포 실행을 위한 Ansible Playbook 전송 및 실행.

jenkinsfile

pipeline {
    agent any

    tools {
        // Install the Maven version configured as "M3" and add it to the path.
        maven "M2_HOME"
    }

    stages {
        stage('Java Build') {
            steps {
                // Run Maven on a Unix agent.
                sh "mvn -Dmaven.test.failure.ignore=true clean package -f pom.xml"
            }
        }
        stage('Docekr Image Build With Remote Ansible Server AND Remote Docker Server Using Publish Over SSH Module') {
            steps {
                sshPublisher(publishers: [sshPublisherDesc(configName: 'ansible-host', transfers: [sshTransfer(cleanRemote: false, excludes: '', execCommand: '', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: 'java-hello-world', remoteDirectorySDF: false, removePrefix: 'webapp/target/', sourceFiles: 'webapp/target/webapp.war'), sshTransfer(cleanRemote: false, excludes: '', execCommand: '', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: 'java-hello-world', remoteDirectorySDF: false, removePrefix: 'docker/', sourceFiles: 'docker/Dockerfile'), sshTransfer(cleanRemote: false, excludes: '', execCommand: '''scp java-hello-world/Dockerfile 13.125.234.12:~/
scp java-hello-world/webapp.war 13.125.234.12:~/
TOKEN=`echo $TOKEN` BUILD_NUMBER=`echo $BUILD_NUMBER` ansible-playbook java-hello-world/docker_build_and_push.yaml
BUILD_NUMBER=`echo $BUILD_NUMBER` ansible-playbook java-hello-world/kube_deploy.yaml''', execTimeout: 120000, flatten: false, makeEmptyDirs: false, noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: 'java-hello-world', remoteDirectorySDF: false, removePrefix: 'playbook/', sourceFiles: 'playbook/*.yaml')], usePromotionTimestamp: false, useWorkspaceInPromotion: false, verbose: true)])
            }
        }
    }
}

5. 구현 결과

5-1. Jenkins build

5-2. 로컬에서 접근

5-3. 웹사이트에서 접근

6. 결론

6-1. As-is

• 기본적으로 이번 프로젝트에서 Jenkins를 통한 GitOps CI/CD는 성공했다.

• Terraform과 Ansible을 사용하여 빌드를 자동화하는데 어느정도 구축은 했다.

6.2. To-be

• 앤서블 플레이북 작성시 몇몇 명령어가 실행되지 못한 점이 아쉬웠다.
• 앤서블 플레이북을 지금은 shell과 command위주로 사용했는데 모듈을 사용하면 더 완성도있는 결과를 낼 수 있었을것같다.
• 로드밸드밸런서와 오토스케일링을 활용한 웹서비스 배포를 GUI환경에서는 성공했지만 마지막에 IaC로 구현한 인프라에서는 작동하지 못한 점이 아쉬웠다.
• 보안그룹을 지금은 간단하게 열어놓았지만 좀더 최적화해서 보안그룹을 구성하면 더 좋을 것 같다.
• workernode를 오토스케일링 하여 자동으로 추가하는 작업도 GUI환경에서는 성공했지만 IaC로 구현한 인프라에서는 작동하지 못한 점 또한 아쉽게 되었다.
• 배스천 호스트를 오토스케일링하고 네트워크 로드밸런서로 구성하여 도메인 네임 엔드포인트로 ssh는 것도 GUI환경에서 성공했지만 IaC로 구현하면서 시간이 부족하여 구성하지 못한 점도 아쉽게 되었다.

GitOps의 구현체

Argo공식site: https://argo-cd.readthedocs.io/en/stable/

1) Install Argo CD

Argo설치를 위해선 (kubernetes 필요)

• Installed kubectl command-line tool.
• Have a kubeconfig file (default location is ~/.kube/config).

  kubectl create namespace argocd
  kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

  

2) Download Argo CD CLI

curl -sSL -o /usr/local/bin/argocd https://github.com/argoproj/argo-cd/releases/latest/download/argocd-linux-amd64

chmod +x /usr/local/bin/argocd

cli 설치 링크: https://argo-cd.readthedocs.io/en/stable/cli_installation/

kubectl get all -n argocd
# argocd-server    Cluster-IP 확인

외부에서 접근하도록 설정 필요.

3) argo CD 서비스 노출

• 로드밸런서 타입으로 변경

  kubectl patch svc argocd-server -n argocd -p '{"spec": {"type": "LoadBalancer"}}'
  

kubectl describe svc argocd-server -n argocd

Load Balancer Port 확인

![](https://velog.velcdn.com/images/sunny-10/post/4ec8b3c9-3615-4bc1-986f-7aae01182714/image.PNG)

#### 4) 웹 브라우저에서 login
웹브라우저에서 [master_IP]:[port]
    예)  192.168.59.10:31958
https 로 redirect됨.


web UI의 로그인 계정은 admin
암호는 확인해서 입력

kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d; echo

[문자들이 나옴]= 암호
![](https://velog.velcdn.com/images/sunny-10/post/2f83bc7a-d04a-4689-a868-67008faeb379/image.PNG)![](https://velog.velcdn.com/images/sunny-10/post/ad26c7d7-1fe7-4b01-9a67-030bbe6b3f43/image.PNG)


#### 5) CLI도 argocd 로그인

argocd 엔터 argocd login --insecure : 192.168.100.100:65001

login id : admin
password : (위에서 확인한 문자)

![](https://velog.velcdn.com/images/sunny-10/post/31d5e93c-21b1-4d6f-9a19-447fe0a8bbd7/image.PNG)

#### 6) application 생성하기 - CLI

argocd app create guestbook --repo https://github.com/argoproj/argocd-example-apps.git --path guestbook --dest-server https://kubernetes.default.svc --dest-namespace default

source : (git) --repo https://github.com/argoproj/argocd-example-apps.git --path guestbook 

destination ; local kubernetes cluster
    --dest-server https://kubernetes.default.svc --dest-namespace 
![](https://velog.velcdn.com/images/sunny-10/post/5439a4bf-4e1b-4b34-aca6-b8f3f4aed58f/image.PNG)


#### 7) CLI로 application 확인

argocd app get guestbook

webui로 확인하시면 노란색 (동기화 안됨)

CLI 동기화 하기 

argocd app sync guestbook argocd app get guestbook

![](https://velog.velcdn.com/images/sunny-10/post/d995350c-f1bd-430a-8aa4-e0c79994ee91/image.PNG)![](https://velog.velcdn.com/images/sunny-10/post/52925320-8fda-4b6c-b80e-fec7fdebb9be/image.PNG)


ArgoCD web UI에서 guestbook application을 삭제해보기
kubernetes 확인


#### 8) guestbook appliname을 WEB UI에서 생성하기
web UI에서 동기화


git------------------kubernetes cluster
        applicaton

git 로그인 repository 생성

guestbook-ui-deployment.yaml

apiVersion: apps/v1 kind: Deployment metadata: name: guestbook-ui spec: replicas: 1 revisionHistoryLimit: 3 selector: matchLabels: app: guestbook-ui template: metadata: labels: app: guestbook-ui spec: containers: - image: gcr.io/heptio-images/ks-guestbook-demo:0.2 name: guestbook-ui ports: - containerPort: 80

guestbook-ui-svc.yaml

apiVersion: v1 kind: Service metadata: name: guestbook-ui spec: ports:

• port: 80 targetPort: 80 selector: app: guestbook-ui

  ![](https://velog.velcdn.com/images/sunny-10/post/46028ac5-29a5-4d09-a0e3-57333c7ca862/image.PNG)
  /guestbook/ 하위에 등록
  

9) git repo와 kubernetes cluster를 연동하는 application을 생성해보기

source : git URL https : https://github.com/soyoung-2020/argocd.git (**) ssh : git@github.com:Sunny-1030/argocd.git PATH : repository 하위 디렉토리 명 . guestbook repository 하위에 바로 yaml 파일이있을 경우에는 . project : default

destination https://kuberntes.default.svc namespace : default (다른 이름이 지정이 가능하나, 미리 생성해야함)

application name : myguestbook

myguestbook을 kubernetes cluster와 동기화

10) git repository - guestbook-ui-deployment.yaml

1차 변경 replicas: 1 ---> 2 개
local pc라면 commit > push

git site에서 편집

11) argoCD webui에서 git소스/live소스를 diff 확인 > 동기화sync

kubectl get all -n default

Argocd WebUI - application 내에서 상단에 “HISTORY”

현시점 외에 과거로 rollback 해보기(2개,1개), 동기화 하면 다시 현재로.(2개)

rollback 시 이전(1개) 으로 돌아가며 sync(동기화)하면 원 상태(2개)로 복구됨

12) kubernetes manifest 를 동기화 해보자.

자신의 git에 repository 생성

nginx-svc.yaml

apiVersion: v1
kind: Service
metadata:
  name: my-nginx
  labels:
    run: my-nginx
spec:
  type:  LoadBalancer    # 서비스 타입
  ports:
  - port: 8080       # 서비스 포트
    targetPort: 80   # 타켓, 즉 pod의 포트
    protocol: TCP
    name: http
  selector:
    app: nginx

nginx-deployment.yaml

apiVersion: apps/v1           # 쿠버네티스 api 버전
kind: Deployment              # 생성할 오브젝트 종류
metadata:                
  name: nginx-deployment      # deployment의 이름
  labels:
    app: nginx                # label 지정
spec:                         # deployment의 스펙을 정의
  replicas: 3                 # 3개의 pod 설정
  selector:                   # deployment가 관리할 pod를 찾는 방법을 정의
    matchLabels:     
      app: nginx
  template:
    metadata:
      labels:                 # pod의 label
        app: nginx
    spec:
      containers:             # 컨테이너 설정
      - name: nginx          
        image: nginx:1.14.2
        ports:
        - containerPort: 80

13) templates 이용하는 방법 - helm (helm chart)

application 추가 repository : git -> helm

repository : https://github.com/argoproj/argocd-example-apps.git path : apps chart : repository를 인식하면 자동으로 목록 뜸. Chart.yaml 선택

하단에 helm 설정파트가 있음 values: values.yaml (또는 values.yaml파일을 보제하여 값을 변경하고자하는 셋팅가능)

repository -HTTPS git연결 -SSH git 연결 key 생성 github : public key 등록 argocd : private 등록, repository 등록 -> application 연결에 사용

Code --> Kubernetes

• Git/GitHub
• Jenkins
• Ansible
• Docker Image
• Code(Java) - Tomcat

Jenkins 설치

sudo apt install openjdk-11-jdk

curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo tee \
    /usr/share/keyrings/jenkins-keyring.asc > /dev/null

echo "deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
    https://pkg.jenkins.io/debian-stable binary/" | sudo tee \
    /etc/apt/sources.list.d/jenkins.list > /dev/null

sudo apt-get update
sudo apt-get install fontconfig jenkins

systemctl status jenkins

http://X.X.X.X:8080

sudo cat /var/lib/jenkins/secerts/initialAdminPassword

접속 확인을 할 수 있다.

수업 예제(test)

1) 새로운 item -> Freestyle Project -> build 2) apply -> 저장 후 build now 로 결과(콘솔창) 확인

Maven

Maven: Java 프로젝트 빌드 도구 빌드:

1. validate: 필요한 정보가 있는지 확인
2. compile: 소스코드 컴파일
3. test: 컴파일된 코드단위 테스트
4. package: JAR/WAR 파일로 생성
5. verify: 통합 테스트
6. install: 로컬 저장소에 배포(~/.m2/repository)
7. deploy: 원격 저장소에 배포

소스코드

git clone https://github.com/Sunny-1030/source-java-maven-hello-world  

#강사님 github에서 fork

sudo apt install maven 

mvn clean package  #war파일로 만들어 줌

시스템 환경구성 ~/.zshrc 또는 ~/.bashrc

JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64/
M2_HOME=/usr/share/maven
M2=$M2_HOME/bin

PATH=$PATH:$JAVA_HOME:$M2:$M2_HOME

source ~/.zshrc

또는

source ~/.bashrc

플러그인 설치

• jenkins관리 -> 플러그인 관리
• 설치가능에서 maven 검색
• maven invoker & integration 선택 후
• install without restart 새로운 item 에서 maven project 구성 확인 가능

Global Tool 설정

jenkins관리에 global tool 선택

1) JDK 설정 name JAVA_HOME 위치 /usr/lib/jvm/java-11-openjdk-amd64/ 2) Maven설정 name M2_HOME 위치 /usr/share/maven

maven test

1) 소스코드 git 선택 https://github.com/Sunny-1030/source-java-maven-hello-world

2) branch 정의 */main

3) build Goals 설정 clean package

Credentials 구성 가능

mange credentials jenkins-global 선택 add credential 할 수 있음

Tomcat

sudo apt install tomcat9 tomcat9-admin

systemctl status tomcat9

브라우저로 접속 IP: 192.168.59.12:8080

docBase

/var/lib/tomcat9/webapp/ROOT

Tomcat Admin Management

관리자 페이지에 접속하기 ID 와 password를 설정해주어야 접속이 가능

http://192.168.59.11:8080/manager/html

Admin Mgmt 계정/패스워드

/etc/tomcat9/tomcat-user.xml

<tomcat-users xmlns="http://tomcat.apache.org/xml"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://tomcat.apache.org/xml tomcat-users.xsd"
              version="1.0">
        <role rolename="manager-gui"/>
        <role rolename="manager-script"/>
        <role rolename="manager-jmx"/>
        <role rolename="manager-status"/>
        <user username="admin" password="P@ssw0rd" roles="manager-gui, manager-script, manager-jmx, manager-status"/>
</tomcat-users>

admin설정 후 tomcat9 재시작

sudo systemctl restart tomcat9

설정한 id와 pw로 관리자 페이지 접속가능

Ansible with Docker

Ansible로 docker_* 모듈로 Docker 호스트 관리

sudo apt install python3-pip

sudo pip3 install docker

docker 엔진 설치 참고링크: https://docs.docker.com/engine/install/ubuntu/ 유저 권한까지 부여해 준다.

id -a 
docker ps

# 권한 확인 , 적용안될 시 재접속

webapp.war file을 docker host로 이동

cd webapp.war /tmp
scp /tmp/webapp.war 192.168.59.12:/tmp

Docker(vm) 에서 Deploy하기

cp /tmp/webapp.war .

vi Dockerfile   #도커파일생성 아래사진 참고

docker build -t myapp .
docker run -d -p 8080:8080 myapp

webapp 접속 확인

curl localhost:808/webapp/  # port가 겹쳐서 808로 설정

jenkins 자동화를 위해 현재 docker conatainer/images 삭제 (정리)

docker ps
docker rm -f xx

docker images
docker rmi xx

jenkins와 tomcat port 겹쳤을 경우 jenkins port 변경 sudo vi /etc/default/jenkins sudo vi /etc/init.d/jenkins 의 port를 모두 변경해야함 sudo /etc/init.d/jenkins restart

jenkins를 통한 docker 자동화

jenkins 관리 -> 플러그인 매니저 설치가능 -> artifact 검색 Publish Over SSH 설치

새로운 Item 구성 (maven project) (이전과 같은 포멧으로 설정) 빌드 후 조치 send build artifacts over SSH 서버 설정을 위해 잠시 저장

jenkins관리 -> 시스템설정 (맨 아래) Publish over SSH SSH Servers 추가

• name docker-host
• hostname

192.168.59.12

• username vagrant
• Remote Directory 설정 안하면 default값

고급 누르면 추가적인 기능생성 간단하게 password만 작성 Test Configuration으로 확인

다시 구성으로 이동 서버설정에 서버가 생성된 것을 확인 할 수 있음

transfers -source files webapp/target/webapp.war

-remote directory myweb (비워두면 홈디렉토리)

apply -> 저장

Build Now

docker(vm)에서 확인 webapp 이 들어온 것을 확인할 수 있음 단, webapp/target/webapp.war를 통으로 가져오기에 사용상 문제는 없으나 경로를 쓰기 귀찮을 수 있음

이때, 쓰는 것 Remove prefix에 제거할 경로를 입력하면 복사할 시 지정된 경로는 제거된다. 깔끔히 webapp/target은 사라지고 바로 webapp.war를 볼 수 있다.

(실습)

cd source-java-maven-hello-world

vi Dockerfile

From tomcat:9.0-jre11-openjdk

COPY webapp.war /usr/local/tomcat/webapps

git add .

git commit -m 'add dockerfile'

git push

name: Sunny-1030
password: 발급받은 token 입력

github 에서 dockerfile 확인

다시 Deploy-to-docker 구성 add transfer set 클릭

• source file Dockerfile

• remove

• remote directory myweb apply -> 저장 -> Build Now jenkins(vm)에서 docker(vm)으로 이동을 확인할 수 있다.

실패 시 debuging 할때 콘솔창에서 상세정보를 보기위해 구성 -> ssh server -> 고급 verbose output 선택(자세히 볼수 있음)

exec command

cd /home/vagrant/myweb
docker build -t myweb .
docker run -d -p 8080:8080 myweb

apply -> 저장

docker build & deploy 확인

docker image

docker ps

curl localhost:8080/webapp/

빌드유발 시 poll SCM 을 걸면 오류가 발생 H * * * * (= * * * * * ) 매분 앞뒤로 약간의 편차를 줌 H Hash

: : :

jenkins + ansible 멱등성을 위해

vm은 jenkins 1대 ansible1대 docker1대 준비 ansible vm 에는 ansible과 docker가 같이 있어야함

sudo apt update
sudo apt install ansible

docker 설치 링크: https://docs.docker.com/engine/install/ubuntu/

ansible 에서 docker vm ssh 연결

ssh-keygen
ssh-copy-id vagrant@192.168.59.12
ssh-copy-id vagrant@192.168.59.13

#인벤토리 설정
vi .ansible.cfg
[defaults]
inventory = hosts.ini

#호스트 설정
vi hosts.ini
[ansible_host]
192.168.58.13
[docker_host]
192.168.59.12

ansible all -m ping   #연결확인

jenkins관리 -> 시스템 설정 -> (맨 아래) publish [추가]

• name ansible-host
• host name

192.168.59.13

• username vagrant

[고급] -> use password (check)

• password vagrant

testconfiguration 클릭하여 success 확인

apply ->저장

1. command로 배포하기

jenkins 새로운 Item -> maven project 기존과 동일하게 설정 git ->레포지토리 주소 branch -> */main golas -> clean package

빌드 후 조치 [send build artifacts over SSH]

(server - name)
ansible-host

(source file)
webapp/target/webapp.war

(remove prefix)
webapp/target

(remote directory)
java-hello-world

추가

(source file)
Dockerfile

(remote directory)
java-hello-world

추가

(source file)
docker_build_and_push.yaml

(remove prefix)
playbook

(remote directory)
java-hello-world

(exec command)
ansible-playbook java-hello-world/docker_build_and_push.yaml

apply -> 저장

2. jenkins vm 에서

mkdir playbook cd playbook

vi docker_build_and_push.yaml

- name: Docker Image Build
  hosts: ansible_host
  gather_facts: false

  tasks:
    - command: docker image build -t java-hello-world java-hello-world/
    - command: docker container rm -f java-hello-world
      ignore_errors: yes
    - command: docker container run --name java-hello-world -d -p 8080:8080 java-hello-world

git add .
git commit -m 'create docker'
git push origin main


name -> Sunny-1030
password -> 토큰

git push가 안될 경우 [에러 문구]

 ! [rejected]        main -> main (non-fast-forward)
error: failed to push some refs to 'https://github.com/Sunny-1030/source-java-maven-hello-world'

git pull origin main --allow-unrelated-histories

ansible(vm) 확인

docker ps
docker images

#tip 토큰을 변수처리 Default Value에 토큰 값 넣기 (docker 토큰을 넣어야함!)

docker repogitory create 생성하기 -> git push

확인 후 docker container 삭제하기

docker rm -f `docker ps -a -q`
docker ps

Ansible with Kubernetes

tip vi편집기 붙여넣기 오류 :set paste 엔터 로 일시적 해결

참고링크: [재민님 블로그] https://velog.io/@repush/CICD-%EA%B7%B8%EB%8C%80%EB%A1%9C-%EB%94%B0%EB%9D%BC%ED%95%98%EA%B8%B0-5%ED%8E%B8

Ansible로 k8s_* 모듈을 사용하여 Kubernetes 호스트 관리

사전 구성:

• kubectl 명령
• kubeconfig 파일

sudo apt install python3-pip

sudo pip3 install openshift==0.11

시점에 따라 사용하는 버전이 다를 수 있음

저장소 만들기

버전관리를 하지 않는 로컬 디렉토리

mkdir mygit
cd mygit

git init

기존 Git 저장소 클론

git clone <URL>

Git 프로젝트의 세 가지 상태

파일의 생명주기

상태 확인

git status

스테이징

git add <FILE>
git add .

.gitignore 파일

• 아무것도 없는 라인이나, #로 시작하는 라인은 무시한다.
• 표준 Glob 패턴을 사용한다. 이는 프로젝트 전체에 적용된다.
• 슬래시(/)로 시작하면 하위 디렉토리에 적용되지(Recursivity) 않는다.
• 디렉토리는 슬래시(/)를 끝에 사용하는 것으로 표현한다.
• 느낌표(!)로 시작하는 패턴의 파일은 무시하지 않는다.

Staged와 Unstaged 상태 변경 내용 보기

staged 상태가 아닌 파일 비교

git diff

커밋과 staged 상태 비교

git diff --staged

변경사항 커밋(버저닝, 스냅샷)

git commit

기본 에디터 변경 git config --global core.editor <EDITOR>

인라인 메시지

git commit -m <MESSAGE>

스테이징 및 인라인 메시지

git commit -a -m <MESSAGE>

좋은 Commit 메시지

https://gist.github.com/robertpainsi/b632364184e70900af4ab688decf6f53

파일 삭제

rm <FILE>

삭제한 파일 Staged 상태

git rm <FILE>

파일명 변경

git mv <ORGION> <NEWFILE>

커밋 히스토리/로그

git log

로그 출력 변경 git config --global core.pager 'less' git config --global core.pager ''

git log --oneline

수업 중 예제

1) vi pod.yaml 파일 생성 후 2) git add pod.yaml or .(전체 파일 add) 3) git status 상태확인 4) git config 정보 등록

git config --global user.email "ypjs09@gmail.com"
git config --global user.name "Suny-1030"
git config --global --list

5)git commit message 확인

git commit -m "create config"   
  #-m 으로 상태창에 진입하지 않고 바로 commit message를 작성할 수 있음

git log
git log --oneline     # 한줄로 로그 확인 가능

6) 이전 버전으로 돌아가기

git checkout

7) 최근 상태로 돌아가기

git checkout master

8) 파일명 변경

git mv pod.yaml mypod.yaml

9) 기존 commit mesage 사용

git commit --amend

HEAD -> 바라보는 곳

10) branch 이용

git branch dev1 
git checkout dev1
git log 

11) branch dev1 에서 새로운 yaml파일을 구성하여 add/commit

git log --oneline --graph   #변경된 HEAD의 위치를 확인

12) branch 삭제

git branch -d dev1
git branch -D dev1   # 강제삭제

13) branch 생성

git checkout -b dev2   # 없는 branch 생성 후 이동

14) git 병합

git merge dev2

merge의 충돌 다른 branch에서 같은 파일의 같은 라인을 수정 하여 병합하면 충돌이 일어남

15) branch name 변경하기

git branch -M main    #사용중일 때는 m 을 못씀

16) remote 하기

git remote add origin https://github.com/Sunny-1030/effective-eureka.git

17) push 하기

git push -u origin main

username sunnuy-1030
password *****
(만약 이중인증이면 토큰 발급을 해야함)

만약 github에서 직접 수정을 하면 (fetch -> fast-forward) git fetch origin

18) fast-forward

git merge origin/main
(fast-forward)

github 협업시 세팅 -> collaborators -> add people (많은 collaborator는 x) Fork -> 다른사람의 레포지터리를 가져올 수 있다

19) tag 생성

git tag -a 'v0.1' -m 'Version 0.1'
git tag -l
git push origin v0.1

20) ssh key 등록하기

ssh-keygen

cat id_rsa.pub 복사

github에 붙여넣기

git 간편안내서

참고링크: https://rogerdudler.github.io/git-guide/index.ko.html

참고링크: https://docs.aws.amazon.com/ko_kr/eks/latest/userguide/getting-started.html

choco install awscli aws-iam-authenticator eksctl kubernetes-helm

AWS에서 사용자 생성(.csv 파일 받기)

aws configure

eksctl create cluster --name myeks --nodes=3 --region=ap-northeast-2

안되는 것들 Load Balancer Service = class lb -> nlb Ingress: X kubectl top: X -> HPA X

클러스터 네트워킹 참고링크: https://kubernetes.io/ko/docs/concepts/cluster-administration/networking/

YAML 파일을 이용한 EKS 배포

mkdir aws-eks
cd aws-eks

myeks.yaml

apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

metadata:
  name: myeks-custom
  region: ap-northeast-2
  version: "1.22"

# AZ
availabilityZones: ["ap-northeast-2a", "ap-northeast-2b",  "ap-northeast-2c"]

# IAM OIDC & Service Account
iam:
  withOIDC: true
  serviceAccounts:
    - metadata:
        name: aws-load-balancer-controller
        namespace: kube-system
      wellKnownPolicies:
        awsLoadBalancerController: true
    - metadata:
        name: ebs-csi-controller-sa
        namespace: kube-system
      wellKnownPolicies:
        ebsCSIController: true
    - metadata:
        name: cluster-autoscaler
        namespace: kube-system
      wellKnownPolicies:
        autoScaler: true

# Managed Node Groups
managedNodeGroups:
  # On-Demand Instance
  - name: myeks-ng1
    instanceType: t3.medium
    minSize: 2
    desiredCapacity: 3
    maxSize: 4
    privateNetworking: true
    ssh:
      allow: true
      publicKeyPath: ./keypair/myeks.pub
    availabilityZones: ["ap-northeast-2a", "ap-northeast-2b", "ap-northeast-2c"]
    iam:
      withAddonPolicies:
        autoScaler: true
        albIngress: true
        cloudWatch: true
        ebs: true

# Fargate Profiles
fargateProfiles:
  - name: fg-1
    selectors:
    - namespace: dev
      labels:
        env: fargate


# CloudWatch Logging
cloudWatch:
  clusterLogging:
    enableTypes: ["*"]

mkdir keypair
ssh-keygen -f keypair/myssh

eksctl create cluster -f myeks.yaml

Classic LoadBalancer는 ec2에만 작동

NLB for LoadBalancer Service

https://docs.aws.amazon.com/ko_kr/eks/latest/userguide/network-load-balancing.html https://docs.aws.amazon.com/ko_kr/eks/latest/userguide/alb-ingress.html https://docs.aws.amazon.com/ko_kr/eks/latest/userguide/aws-load-balancer-controller.html

AWS Load Balancer Controller 설치

helm repo add eks https://aws.github.io/eks-charts
helm repo update

helm install aws-load-balancer-controller eks/aws-load-balancer-controller -n kube-system --set clusterName=myeks-custom --set serviceAccount.create=false --set serviceAccount.name=aws-load-balancer-controller --set image.repository=602401143452.dkr.ecr.ap-northeast-2.amazonaws.com/amazon/aws-load-balancer-controller

샘플 코드

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myweb-deploy
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb
          ports:
            - containerPort: 8080

apiVersion: v1
kind: Service
metadata:
  name: myweb-svc-lb
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-type: "external"
    service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: "instance"
    service.beta.kubernetes.io/aws-load-balancer-scheme: "internet-facing"
spec:
  type: LoadBalancer
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 8080

• service.beta.kubernetes.io/aws-load-balancer-nlb-target-type
  • instance: EC2 타겟
  • ip: Pod 타겟(Fargate)
• service.beta.kubernetes.io/aws-load-balancer-scheme
  • internal: 내부
  • internet-facing: 외부

internet-facing 설정을 안해주면 lb는 private에 설치됨

Ingress for ALB

https://docs.aws.amazon.com/ko_kr/eks/latest/userguide/alb-ingress.html

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myweb-ing
  annotations:
    kubernetes.io/ingress.class: alb
    alb.ingress.kubernetes.io/target-type: instance
    alb.ingress.kubernetes.io/scheme: internet-facing
spec:
  rules:
    - http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: myweb-svc-lb
                port:
                  number: 80

• alb.ingress.kubernetes.io/target-type
  • instance: EC2 타겟
  • ip: Pod 타겟(Fargate)
• alb.ingress.kubernetes.io/scheme
  • internal: 내부
  • internet-facing: 외부

internet-facing 설정을 안해주면 lb는 private에 설치됨

EBS for CSI

• EBS 스냅샷
• EBS 크기 변경

https://docs.aws.amazon.com/ko_kr/eks/latest/userguide/managing-ebs-csi.html

eksctl get iamserviceaccount --cluster myeks-custom      #arn 확인

NAMESPACE       NAME                            ROLE ARN
kube-system     aws-load-balancer-controller    arn:aws:iam::065144736597:role/eksctl-myeks-custom-addon-iamserviceaccount-Role1-11N0OKMVG2DYY
kube-system     aws-node                        arn:aws:iam::065144736597:role/eksctl-myeks-custom-addon-iamserviceaccount-Role1-CLMK7A6K5NL3
kube-system     cluster-autoscaler              arn:aws:iam::065144736597:role/eksctl-myeks-custom-addon-iamserviceaccount-Role1-1S02W28MZOSL4
kube-system     ebs-csi-controller-sa           arn:aws:iam::065144736597:role/eksctl-myeks-custom-addon-iamserviceaccount-Role1-15HLE8HBOD9CN

eksctl create addon --name aws-ebs-csi-driver --cluster myeks-custom --service-account-role-arn  arn:aws:iam::065144736597:role/eksctl-myeks-custom-addon-iamserviceaccount-Role1-15HLE8HBOD9CN --force
(나에게 맞는 arn으로 변경)

kubectl get po -n kube-system

kubectl get sc

Metrics Server

https://docs.aws.amazon.com/ko_kr/eks/latest/userguide/metrics-server.html

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

kubectl get po -n kube-system

kubectl top nodes

Cluster Autoscaler

수동 스케일링

eksctl scale nodegroup --name myeks-ng1 --cluster myeks-custom --nodes 2

자동 스케일링

https://docs.aws.amazon.com/ko_kr/eks/latest/userguide/autoscaling.html

curl -o cluster-autoscaler-autodiscover.yaml https://raw.githubusercontent.com/kubernetes/autoscaler/master/cluster-autoscaler/cloudprovider/aws/examples/cluster-autoscaler-autodiscover.yaml

cluster-autoscaler-autodiscover.yaml

163: - --node-group-auto-discovery=asg:tag=k8s.io/cluster-autoscaler/enabled,k8s.io/cluster-autoscaler/myeks-custom
(163번째 열에 클러스터 이름변경)

kubectl apply -f cluster-autoscaler-autodiscover.yaml

(적용이 된다면 사용)
kubectl patch deployment cluster-autoscaler -n kube-system -p '{"spec":{"template":{"metadata":{"annotations":{"cluster-autoscaler.kubernetes.io/safe-to-evict": "false"}}}}}'

kubectl -n kube-system edit deployment.apps/cluster-autoscaler

      - command:
        - ./cluster-autoscaler
        - --v=4
        - --stderrthreshold=info
        - --cloud-provider=aws
        - --skip-nodes-with-local-storage=false
        - --expander=least-waste
        - --node-group-auto-discovery=asg:tag=k8s.io/cluster-autoscaler/enabled,k8s.io/cluster-autoscaler/myeks-custom
        - --balance-similar-node-groups
        - --skip-nodes-with-system-pods=false
        image: k8s.gcr.io/autoscaling/cluster-autoscaler:v1.22.6

수정

• --node-group-auto-discovery=asg:tag=k8s.io/cluster-autoscaler/enabled,k8s.io/cluster-autoscaler/myeks-custom
• --balance-similar-node-groups
• --skip-nodes-with-system-pods=false
• image: k8s.gcr.io/autoscaling/cluster-autoscaler:v1.22.2

kubectl set image deployment cluster-autoscaler -n kube-system cluster-autoscaler=k8s.gcr.io/autoscaling/cluster-autoscaler:v1.22.2

cluster autoscaler 로그 보기

kubectl -n kube-system logs -f deployment.apps/cluster-autoscaler

샘플 코드

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myweb-deploy
spec:
  replicas: 2
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb:alpine
          ports:
            - containerPort: 8080
          resources:
            requests:
              cpu: 200m
              memory: 200M
            limits:
              cpu: 200m
              memory: 200M

CloudWatch Container Insight

https://docs.aws.amazon.com/ko_kr/AmazonCloudWatch/latest/monitoring/Container-Insights-setup-EKS-quickstart.html

https://github.com/git-for-windows/git/releases/download/v2.36.1.windows.1/Git-2.36.1-64-bit.exe (window bash가 없어서 64비트로 받아준다)

ClusterName=myeks-custom
RegionName=ap-northeast-2
FluentBitHttpPort='2020'
FluentBitReadFromHead='Off'
[[ ${FluentBitReadFromHead} = 'On' ]] && FluentBitReadFromTail='Off'|| FluentBitReadFromTail='On'
[[ -z ${FluentBitHttpPort} ]] && FluentBitHttpServer='Off' || FluentBitHttpServer='On'
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/daemonset/container-insights-monitoring/quickstart/cwagent-fluent-bit-quickstart.yaml | sed 's/{{cluster_name}}/'${ClusterName}'/;s/{{region_name}}/'${RegionName}'/;s/{{http_server_toggle}}/"'${FluentBitHttpServer}'"/;s/{{http_server_port}}/"'${FluentBitHttpPort}'"/;s/{{read_from_head}}/"'${FluentBitReadFromHead}'"/;s/{{read_from_tail}}/"'${FluentBitReadFromTail}'"/' | kubectl apply -f - 

Fargate

EC2 인스턴스 사용 , 파드를 실행

https://docs.aws.amazon.com/ko_kr/eks/latest/userguide/fargate.html

kubectl create ns dev

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myfg
  namespace: dev
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myfg
  template:
    metadata:
      labels:
        app: myfg
        env: fargate
    spec:
      containers:
      - name: myfg
        image: ghcr.io/c1t1d0s7/go-myweb
        resources:
          limits:
            memory: "128Mi"
            cpu: "500m"
        ports:
        - containerPort: 8080

apiVersion: v1
kind: Service
metadata:
  name: mysvc
  namespace: dev
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-type: "external"
    service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: "ip"
    service.beta.kubernetes.io/aws-load-balancer-scheme: "internet-facing"
spec:
  selector:
    app: myfg
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer

VPA

https://docs.aws.amazon.com/ko_kr/eks/latest/userguide/vertical-pod-autoscaler.html

사전 요구 사항

• openssl 1.1.1 이상
• metrics-server

git clone https://github.com/kubernetes/autoscaler.git

cd autoscaler/vertical-pod-autoscaler/

/hack/vpa-up.sh

kubectl get pods -n kube-system

VPA 예제

kubectl apply -f examples/hamster.yaml

클러스터 삭제

eksctl delete cluster -f .\myeks.yaml --force --disable-nodegroup-eviction

cloud watch 로그 리소스 삭제 해주기

Tip

lens

gui 방식으로 인터페이스 서비스 가능 참고링크: https://k8slens.dev/

choco install lens
(패키지 설치 시 에는 관리자 권한으로 접속)

k9s

tui 방식으로 인터페이스 서비스(text 형식) 참고링크: https://k9scli.io/

choco install k9s

k9s

visual studio code

extension(확장) kubernetes 설치 (docker도 설치가능)

choco install kubernetes-helm

ctl + shift + p 명령줄에 바로 kubernetes create 가능(터미널 창에 치지 않아도 됨)

minikube

https://minikube.sigs.k8s.io/docs/start/

choco install minikube
(관리자 권한으로 설치)

choco install kubernetes-cli --version=1.22.4

클러스터 생성/실행

minikube start
(기본값으로 설치됨)

클러스터 중지

minikube stop

클러스터 상태

minikube status

VM 접속

minikube ssh

패키지 관리자 X kubectl 명령 X docker 명령 O

VM 내의 Docker Engine 사용

choco install docker-cli
(docker command 만 설치, 서버x)

minikube -p minikube docker-env --shell powershell | Invoke-Expression
(변수는 해당 터미널에서만 유효)

docker ps

클러스터 삭제

minikube delete

추가 옵션을 사용한 클러스터 생성/시작

minikube start --cpus 4 --memory 4G --disk-size 30G --driver virtualbox --kubernetes-version v1.22.9

노드 추가

minikube node list
minikube node add     #자동으로 join해줌

서비스 목록 확인

minikube service list

애드온

minikube addons list

minikube addons enable metrics-server
minikube addons enable ingress

minikube addons configure metallb

-- Enter Load Balancer Start IP: 192.168.X.200
-- Enter Load Balancer End IP: 192.168.X.209

클러스터 기본 옵션 지정

minikube config set cpus 2
minikube config set memory 4G
minikube config set driver virtualbox
minikube config set kubernetes-version v1.22.9
minikube config view

Kubeconfig

~/.kube/config

apiVersion: v1
kind: Config
preferences: {}
clusters:
- name: cluster.local
  cluster:
    certificate-authority-data: LS0tLS1...
    server: https://127.0.0.1:6443
- name: mycluster
  cluster:
    server: https://1.2.3.4:6443
users:
- name: myadmin
- name: kubernetes-admin
  user:
    client-certificate-data: LS0tLS1...
    client-key-data: LS0tLS1...
contexts:
- context:
    cluster: mycluster
    user: myadmin
  name: myadmin@mycluster
- context:
    cluster: cluster.local
    user: kubernetes-admin
  name: kubernetes-admin@cluster.local
current-context: kubernetes-admin@cluster.local

kubectl config view

kubectl config get-clusters
kubectl config get-contexts
kubectl config get-users

kubectl config use-context myadmin@mycluster

인증

쿠버네티스의 사용자

• Service Account(sa): 쿠버네티스가 관리하는 SA 사용자
  • 사용자 X
  • Pod 사용
• Normal User: 일반 사용자(쿠버네티스가 관리 X)
  • 사용자 O
  • Pod X

인증 방법:

• x509 인증서
• 토큰
  • Bearer Token
    • http 헤더:
    • Authorization: Bearer 31ada4fd-adec-460c-809a-9e56ceb75269
  • SA Token
    • JSON Web Token: JWT
      • OpenID Connect(OIDC)
      • 외부 인증 표준화 인터페이스
      • okta, AWS IAM
      • OAuth2 Provider

RBAC

• Role: 권한(NS)
• ClusterRole: 권한(Global)
• RoleBinding
  • Role <-> RoleBinding <-> SA/User
• ClusterRoleBinding
  • ClusterRole <-> ClusterRoleBinding <-> SA/User

https://kubernetes.io/docs/reference/access-authn-authz/rbac/

요청 동사

• create
  • kubectl create, kubectl apply
• get
  • kubectl get po myweb
• list
  • kubectl get pods
• watch
  • kubectl get po -w
• update
  • kubectl edit, replace
• patch
  • kubectl patch
• delete
  • kubectl delete po myweb
• deletecollection
  • kubectl delete po --all

ClusterRole

• view: 읽을 수 있는 권한
• edit: 생성/삭제/변경 할 수 있는 권한
• admin: 모든것 관리(-RBAC: ClusterRole 제외)
• cluster-admin: 모든것 관리

SA

kubectl create sa <NAME>

사용자 생성을 위한 x509 인증서

Private Key

openssl genrsa -out myuser.key 2048

x509 인증서 요청 생성

openssl req -new -key myuser.key -out myuser.csr -subj "/CN=myuser"

cat myuser.csr | base64 | tr -d "\n"

csr.yaml

apiVersion: certificates.k8s.io/v1
kind: CertificateSigningRequest
metadata:
  name: myuser-csr
spec:
  usages:
  - client auth
  signerName: kubernetes.io/kube-apiserver-client
  request: LS0tLS1CRUdJTiB

kubectl create -f csr.yaml

kubectl get csr

상태: Pending

kubectl certificate approve myuser-csr

kubectl get csr

상태: Approved, Issued

kubectl get csr myuser-csr -o yaml

status.certificates

kubectl get csr myuser-csr -o jsonpath='{.status.certificate}' | base64 -d > myuser.crt

Kubeconfig 사용자 생성

kubectl config set-credentials myuser --client-certificate=myuser.crt --client-key=myuser.key --embed-certs=true

Kubeconfig 컨텍스트 생성

kubectl config set-context myuser@cluster.local --cluster=cluster.local --user=myuser --namespace=default

kubectl config get-users
kubectl config get-clusters
kubectl config get-contexts

kubectl config use-context myuser@cluster.local

클러스터 롤 바인딩 생성

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: myuser-view-crb
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: view
subjects:
  - apiGroup: rbac.authorization.k8s.io
    kind: User
    name: myuser

Helm

용어

• Chart: 차트, 패키지
• Repository: 차트 저장소
• Release: 쿠버네티스 오브젝트 리소스 (패키지 -> 클러스터에 생성한 인스턴스)

helm v3는 tiller를 사용하지 않음

helm client 설치

curl https://baltocdn.com/helm/signing.asc | gpg --dearmor | sudo tee /usr/share/keyrings/helm.gpg > /dev/null
sudo apt-get install apt-transport-https --yes
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/helm.gpg] https://baltocdn.com/helm/stable/debian/ all main" | sudo tee /etc/apt/sources.list.d/helm-stable-debian.list
sudo apt-get update
sudo apt-get install helm

Helm Chart 검색 https://artifacthub.io/

차트 구조

<Chart Name>/
  Chart.yaml
  values.yaml
  templates/

• Chart.yaml: 차트의 메타데이타
• values.yaml: 패키지를 커스터마이즈/사용자화(벨류)
• templates: YAML 오브젝트 파일

helm 사용법

aritifacthub 검색

helm search hub <PATTERN>

저장소 추가

helm repo add bitnami https://charts.bitnami.com/bitnami

저장소 검색

helm search repo wordpress

차트 설치

helm install mywordpress bitnami/wordpress

릴리즈 확인

helm list

릴리즈 삭제

helm uninstall mywordpress

차트 정보 확인

helm show readme binami/wordpress
helm show chart binami/wordpress
helm show values binami/wordpress

차트 사용자화

helm install mywp bitnami/wordpress --set replicaCount=2
helm install mywp bitnami/wordpress --set replicaCount=2 --set service.type=NodePort

릴리즈 업그레이드

helm show value bitnami/wordpress > wp-value.yaml
파일 수정

helm upgrade mywp bitnami/wordpress -f wp-value.yaml

릴리즈 업그레이드 히스토리

helm history mywp

릴리즈 롤백

helm rollback mywp 1

wp-value2.yaml

replicaCount: 1

service:
  type: LoadBalancer

helm upgrade mywp bitnami/wordpress -f wp-value2.yaml

Monitoring & Logging

Prometheus Monitoring

CPU, Memoty, Network IO, Disk IO

• Heapster + InfluxDB: X
  • metrics-server: DB 없음, 실시간
    • CPU, Memory
  • Prometheus

https://github.com/prometheus-community/helm-charts/tree/main/charts/kube-prometheus-stack

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm update

prom-value.yaml

grafana:
  service:
    type: LoadBalancer

kubectl create ns monitor

helm install prom prometheus-community/kube-prometheus-stack -f prom-values.yaml -n monitor

웹브라우저 http://192.168.100.24X ID: admin PWD: prom-operator

EFK Logging

ELK Stack: Elasticsearch + Logstash + Kibana EFK Stack: Elasticsearch + Fluentd + Kibana Elasticsearch + Fluent Bit + Kibana Elastic Stack: Elasticsearch + Beat + Kibana

Elasticsearch

helm repo add elastic https://helm.elastic.co
helm repo update

helm show values elastic/elasticsearch > es-value.yaml

es-value.yaml

 18 replicas: 1
 19 minimumMasterNodes: 1

 80 resources:
 81   requests:
 82     cpu: "500m"
 83     memory: "1Gi"
 84   limits:
 85     cpu: "500m"
 86     memory: "1Gi"

kubectl create ns logging

helm install elastic elastic/elasticsearch -f es-value.yaml -n logging

Fluent Bit

https://github.com/fluent/fluent-bit-kubernetes-logging

git clone https://github.com/fluent/fluent-bit-kubernetes-logging.git

cd  fluent-bit-kubernetes-logging

kubectl create -f fluent-bit-service-account.yaml
kubectl create -f fluent-bit-role-1.22.yaml
kubectl create -f fluent-bit-role-binding-1.22.yaml

kubectl create -f output/elasticsearch/fluent-bit-configmap.yaml

output/elasticsearch/fluent-bit-ds.yaml

 32         - name: FLUENT_ELASTICSEARCH_HOST
 33           value: "elasticsearch-master"

kubectl create -f output/elasticsearch/fluent-bit-ds.yaml

Kibana

helm show values elastic/kibana > kibana-value.yaml

kibana-value.yaml

 49 resources:
 50   requests:
 51     cpu: "500m"
 52     memory: "1Gi"
 53   limits:
 54     cpu: "500m"
 55     memory: "1Gi"

119 service:
120   type: LoadBalancer

helm install kibana elastic/kibana -f kibana-value.yaml -n logging

http://192.168.100.X:5601

• 햄버거 -> Management -> Stack Management
  • Kibana -> Index Pattern
    • Create Index Pattern 우상
      • Name: logstash-*
      • Timestamp: @timestamp
• 햄버거 -> Analystics -> Discover

Tip

Powerlevel10k

git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k

~/.zshrc

ZSH_THEME="powerlevel10k/powerlevel10k"

exec zsh

p10k configure

kubectx & kubens

https://github.com/ahmetb/kubectx

wget https://github.com/ahmetb/kubectx/releases/download/v0.9.4/kubectx

wget https://github.com/ahmetb/kubectx/releases/download/v0.9.4/kubens

sudo install kubectx /usr/local/bin
sudo install kubens /usr/local/bin

nodeName

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myweb-rs-nn
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      nodeName: node2
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb

nodeSelector

노드 레이블 node1

beta.kubernetes.io/arch=amd64
beta.kubernetes.io/os=linux
kubernetes.io/arch=amd64
kubernetes.io/hostname=node1
kubernetes.io/os=linux
node-role.kubernetes.io/control-plane=
node-role.kubernetes.io/master=
node.kubernetes.io/exclude-from-external-load-balancers=

node2

beta.kubernetes.io/arch=amd64
beta.kubernetes.io/os=linux
kubernetes.io/arch=amd64
kubernetes.io/hostname=node2
kubernetes.io/os=linux

node3

beta.kubernetes.io/arch=amd64
beta.kubernetes.io/os=linux
kubernetes.io/arch=amd64
kubernetes.io/hostname=node3
kubernetes.io/os=linux

kubectl label node node1 gpu=highend
kubectl label node node2 gpu=midrange
kubectl label node node3 gpu=lowend

kubectl get nodes -L gpu

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myweb-rs-ns
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      nodeSelector:
        gpu: lowend
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb

Affinity

• affinity
  • pod
  • node
• anti-affinty
  • pod

myweb-a.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myweb-a
spec:
  replicas: 2
  selector:
    matchLabels:
      app: a
  template:
    metadata:
      labels:
        app: a
    spec:
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 10
              preference:
                matchExpressions:
                  - key: gpu
                    operator: Exists
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                 matchLabels:
                   app: a
              topologyKey: "kubernetes.io/hostname"
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb

myweb-b.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myweb-b
spec:
  replicas: 2
  selector:
    matchLabels:
      app: b
  template:
    metadata:
      labels:
        app: b
    spec:
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 10
              preference:
                matchExpressions:
                  - key: gpu
                    operator: Exists
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                 matchLabels:
                   app: b
              topologyKey: "kubernetes.io/hostname"
        podAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                 matchLabels:
                   app: a
              topologyKey: "kubernetes.io/hostname"
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb

Cordon & Drain

Cordon: 스케줄링 금지

kubectl cordon <NODENAME>

스케줄링 허용

kubectl uncordon <NODENAME>

Drain: Cordon -> 기존 파드를 제거

kubectl drain <NODENAME> --ignore-daemonsets

kubectl uncordn <NODENAME>

Taint & Toleration

Control Plane Taint: "node-role.kubernetes.io/master:NoSchedule"

Taint: 특정 노드에 역할을 부여 Toleration: Taint 노드에 스케줄링 허용

kubectl taint node node1 node-role.kubernetes.io/master:NoSchedule

      tolerations:
        - key: node-role.kubernetes.io/master
          operator: Exists
          effect: NoSchedule

myweb-a.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myweb-a
spec:
  replicas: 3
  selector:
    matchLabels:
      app: a
  template:
    metadata:
      labels:
        app: a
    spec:
      tolerations:
        - key: node-role.kubernetes.io/master
          operator: Exists
          effect: NoSchedule
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 10
              preference:
                matchExpressions:
                  - key: gpu
                    operator: Exists
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                 matchLabels:
                   app: a
              topologyKey: "kubernetes.io/hostname"
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb

kubectl cordon node2

kubectl describe nodes | grep -i taint

kubectl uncordon node2

kubdectl describe nodes | grep -i taint

application의 stateful을 관리하는데 사용하는 워크로드 API 오브젝트 파드들의 순서 및 고유성을 보장

pet vs cattle 고유성의 차이

headless service 와 statefullSet을 같이 사용 (headless service필수)

Headless Service

myweb-svc.yaml

apiVersion: v1
kind: Service
metadata:
  name: myweb-svc
spec:
  type: ClusterIP
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 8080

myweb-svc-headless.yaml

apiVersion: v1
kind: Service
metadata:
  name: myweb-svc-headless
spec:
  type: ClusterIP
  clusterIP: None # <-- Headless Service
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 8080

myweb-rs.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myweb-rs
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
      env: dev
  template:
    metadata:
      labels:
        app: web
        env: dev
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb
          ports:
            - containerPort: 8080
              protocol: TCP

kubectl run nettool -it --image ghcr.io/c1t1d0s7/network-multitool --rm

> host myweb-svc
> host myweb-svc-headless 

StatefulSet

예제1

myweb-svc-headless.yaml

apiVersion: v1
kind: Service
metadata:
  name: myweb-svc-headless
spec:
  type: ClusterIP
  clusterIP: None # <-- Headless Service
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 8080

myweb-sts.yaml

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: myweb-sts
spec:
  replicas: 3
  serviceName: myweb-svc-headless
  selector:
    matchLabels:
      app: web
      env: dev
  template:
    metadata:
      labels:
        app: web
        env: dev
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb
          ports:
            - containerPort: 8080
              protocol: TCP

kubectl run nettool -it --image ghcr.io/c1t1d0s7/network-multitool --rm

> host myweb-svc-headless
> host myweb-sts-0.myweb-svc-headless
> host myweb-sts-1.myweb-svc-headless
> host myweb-sts-2.myweb-svc-headless

pod가 삭제 되어도 똑같은 이름으로 다시 생성 이름이 고정적(이름뒤에 서수가 붙음 -예측가능) 순서대로 생성되고 삭제됨

• template: pod생성
• volumeClaimTemplates: 볼륨 pvc생성

예제2: PVC 템플릿

myweb-sts-vol.yaml

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: myweb-sts-vol
spec:
  replicas: 3
  serviceName: myweb-svc-headless
  selector:
    matchLabels:
      app: web
      env: dev
  template:
    metadata:
      labels:
        app: web
        env: dev
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb:alpine
          ports:
            - containerPort: 8080
              protocol: TCP
          volumeMounts:
            - name: myweb-pvc
              mountPath: /data
  volumeClaimTemplates:
    - metadata:
        name: myweb-pvc
      spec:
        accessMode:
          - ReadWriteOnce
        resources:
          requests:
            storage: 1G
        storageClassName: nfs-client

pod가 삭제되어도 pv,pvc는 보존

예제3: mysql

참고링크 https://kubernetes.io/docs/tasks/run-application/run-replicated-stateful-application/

configMap

wget https://k8s.io/examples/application/mysql/mysql-configmap.yaml
(바로 시작 안하고 받아서 수정 후 apply)

primaty.cnf 와 replica.cnf의 
datadir 라인 제거 

kubectl create -f mysql-configmap.yaml

service

kubectl apply -f https://k8s.io/examples/application/mysql/mysql-services.yaml

statefulset

kubectl apply -f https://k8s.io/examples/application/mysql/mysql-statefulset.yaml

kubectl get sts,po,pv,pvc

넷툴로 접속 (--rm 을 사용하면 종료 시 자동으로 삭제됨)

kubectl run nettool -it --image ghcr.io/c1t1d0s7/network-multitool --rm

host확인

host mysql
host mysql-read

node0 master확인 (database 추가)

mysql -h mysql-0.mysql -u root
(0번이 master )
show databases;
create database encore;
exit

node1 (database 확인, 동기화)

mysql -h mysql-1.mysqp -u root
show databases;
(encore 존재 확인)
exit

(database 삭제, 동기화)

mysql -h mysql-0.mysql -u root
drop databases eoncore;
show databases;

mysql -h mysql-1.mysqp -u root
show databases;
(encore 존재 확인)
exit

mysql -h mysql-0.mysql -u root
create database encore;
use database encore;
use encore;
create table encore.message (message VARCHAR(50));
show tables;
insert into encore.message values ("hello mysql");
select * from message;
exit

다른 pod를 생성하여도 볼륨에 바로 동기화가 됨

Auto Scaling

Resource Request & Limit

요청: request 제한: limit

요청 =< 제한

QoS(서비스 품질) Class:

1. BestEffort: 가장 나쁨
2. Burstable
3. Guaranteed: 가장 좋음

• 요청/제한 설정되어 있지 않으면: BestEffort
• 요청 < 제한: Bustable
• 요청 = 제한: Guaranteed

pod.spec.containers.resources

• requests
  • cpu
  • memory
• limits
  • cpu
  • memory

CPU 요청 & 제한: milicore ex) 1500m -> 1.5개, 1000m -> 1개 ex) 1.5, 0.1 Memory 요청 & 제한: M, G, T, Mi, Gi, Ti

myweb-reqlim.yaml

apiVersion: v1
kind: Pod
metadata:
  name: myweb-reqlim
spec:
  containers:
    - name: myweb
      image: ghcr.io/c1t1d0s7/go-myweb
      resources:
        requests:
          cpu: 200m
          memory: 200M
        limits:
          cpu: 200m
          memory: 200M

replace는 resource 변경이 안되나 뒤에 --force를 붙여 강제로 가능 (삭제하고 재생성) 제한(limit)만 설정하면 요청(request)에 같은 값이 설정됨 (요청만 설정하면 제한은 설정이 안됨)

노드별 CPU/Memory 사용량 확인

kubectl top nodes

파드별 CPU/Memory 사용량 확인

kubectl top pods
kubectl top pods -A

리소스 모니터링(인프라 모니터링) Heapster: -> metric-server: 실시간 cpu/memory 모니터링 -> prometheus: 실시간/이전 cpu/memory/network/disk 모니터링

노드별 요청/제한 양 확인

kubectl describe nodes node1

실행 할 수 없는 리소스 myweb-big.yaml

apiVersion: v1
kind: Pod
metadata:
  name: myweb-big
spec:
  containers:
    - name: myweb
      image: ghcr.io/c1t1d0s7/go-myweb
      resources:
        limits:
          cpu: 3000m
          memory: 4000M

pending 이 오래걸리면 스케줄링이 되지 않는지 볼륨이 연결되지않는지, 이미지를 받지 못하는지 의심할 것

HPA: Horisontal Pod AutoScaler

AutoScaling

• Pod
  • HPA
  • VPA: Vertical Pod Autoscaler
• Node
  • ClusterAutoScaler

HPA: Deployment, ReplicaSet, StatefulSet의 복제본 개수를 조정

스케일 아웃: 180초 스케인 인: 300초

myweb-deploy.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myweb-deploy
spec:
  replicas: 2
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb:alpine
          ports:
            - containerPort: 8080
          resources:
            requests:
              cpu: 200m
            limits:
              cpu: 200m

HPA를 위해 최소 request는 설정되여 함

myweb-hpa.yaml

apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
  name: myweb-hpa
spec:
  minReplicas: 1
  maxReplicas: 10
  targetCPUUtilizationPercentage: 50
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myweb-deploy

부하 (강제로 부하걸기)

kubectl exec <POD> -- sha256sum /dev/zero
kubectl exec myweb-deploy-xx~ --sha256sum /dev/zero

원하는 레플리카수 = ceil[ 현재 레플리카 수 * (현재 메트릭 값/원하는 메트릭 값)] (ceil -> celing천장함수-> 올림)

beta2버전 myweb-hpa-v2beta2.yaml

apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: myweb-hpa
spec:
  minReplicas: 1
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          avarageUtilization: 50
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myweb-deploy

Nginx HTTPs 서버

Nginx

• Documentation Root: /usr/share/nginx/html/
• Configuration File: /etc/nginx/conf.d

자체 서명 인증서 생성

ssc(self signed certificate 셀프인증) - 테스트용

Secret:

• Type: kubernetes.io/tls

mkdir x509 && cd x509

Private Key

openssl genrsa -out nginx-tls.key 2048

Public Key

openssl rsa -in nginx-tls.key -pubout -out nginx-tls

CSR

openssl req -new -key nginx-tls.key -out nginx-tls.csr

ssl 인증 시 필요한 정보 예시 :KR (나라) :Seoul (주) :Seoul (시) :Encore Inc. (소속) :IT (전공) :www.example.com (도메인) :admin@encore.com (이메일)

인증서

openssl req -x509 -days 3650 -key nginx-tls.key -in nginx-tls.csr -out nginx-tls.crt

rm nginx-tls nginx-tls.csr

• nginx-tls.key
• nginx-tls.crt

설정파일

ConfigMap

mkdir conf && cd conf

nginx-tls.conf

server {
    listen              80;
    listen              443 ssl;
    server_name         myapp.example.com;
    ssl_certificate     /etc/nginx/ssl/tls.crt;
    ssl_certificate_key /etc/nginx/ssl/tls.key;
    ssl_protocols       TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers         HIGH:!aNULL:!MD5;
    location / {
        root   /usr/share/nginx/html;
        index  index.html;
    }
}

리소스 생성

CM 생성 nginx-tls-config.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx-tls-config
data:
  nginx-tls.conf: |
    server {
      listen              80;
      listen              443 ssl;
      server_name         myapp.example.com;
      ssl_certificate     /etc/nginx/ssl/tls.crt;
      ssl_certificate_key /etc/nginx/ssl/tls.key;
      ssl_protocols       TLSv1 TLSv1.1 TLSv1.2;
      ssl_ciphers         HIGH:!aNULL:!MD5;
      location / {
        root   /usr/share/nginx/html;
        index  index.html;
      }
    }

Secret 생성 nginx-tls-secret.yaml

apiVersion: v1
kind: Secret
metadata:
  name: nginx-tls-secret
type: kubernetes.io/tls
data:
  # base64 x509/nginx-tls.crt -w 0
  tls.crt: |
    LS0tLS1C...
  # base64 x509/nginx-tls.key -w 0
  tls.key: |
    LS0tLS1C...

Pod 생성 nginx-https-pod.yaml

apiVersion: v1
kind: Pod
metadata:
  name: nginx-https-pod
  labels:
    app: nginx
spec:
  containers:
    - name: nginx
      image: nginx
      volumeMounts:
      - name: nginx-config
        mountPath: /etc/nginx/conf.d
      - name: nginx-certs
        mountPath: /etc/nginx/ssl
  volumes:
    - name: nginx-config
      configMap:
        name: nginx-tls-config
    - name: nginx-certs
      secret:
        secretName: nginx-tls-secret

SVC 생성 nginx-svc-lb.yaml

apiVersion: v1
kind: Service
metadata:
  name: nginx-svc-lb
spec:
  type: LoadBalancer
  selector:
    app: nginx
  ports:
    - name: http
      port: 80
      targetPort: 80
    - name: https
      port: 443
      targetPort: 443

Test

curl -k https://192.168.100.X

환경변수

pods.spec.containers.env

• name
• value

apiVersion: v1
kind: Pod
metadata:
  name: myweb-env
spec:
  containers:
    - name: myweb
      image: ghcr.io/c1t1d0s7/go-myweb:alpine
      env:
        - name: MESSAGE
          value: "Customized Hello World"

ConfigMap

사용 용도:

• 환경 변수
• 볼륨/파일
  • 설정파일
  • 암호화 키/인증서

환경 변수

mymessage.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: mymessage
data:
  MESSAGE: Customized Hello ConfigMap

myweb-env.yaml

apiVersion: v1
kind: Pod
metadata:
  name: myweb-env
spec:
  containers:
    - name: myweb
      image: ghcr.io/c1t1d0s7/go-myweb:alpine
      envFrom:
        - configMapRef:
            name: mymessage

apiVersion: v1
kind: Pod
metadata:
  name: myweb-env
spec:
  containers:
    - name: myweb
      image: ghcr.io/c1t1d0s7/go-myweb:alpine
      env:
        valueFrom:
          configMapKeyRef:
            name: mymessage
            key: MESSAGE

configMapRef 와 configMapKeyRef의 차이 configMapRef은 환경변수 전체를 읽음 configMapKeyRef에 지정한 키값만 읽음

파일

myweb-cm-vol.yaml

apiVersion: v1
kind: Pod
metadata:
  name: myweb-cm-vol
spec:
  containers:
    - name: myweb
      image: ghcr.io/c1t1d0s7/go-myweb:alpine
      volumeMounts:
        - name: cmvol
          mountPath: /myvol

  volumes:
    - name: cmvol
      configMap:
        name: mymessage

Secret

value --base64--> encoded data (base64로 인코딩하다보니 암호화되지 않아 안전하지 않음)

안전을 위해 다른 서비스와 같이 사용 Hashicorp Vault AWS KMS ...

환경 변수

mydata.yaml

apiVersion: v1
kind: Secret
metadata:
  name: mydata
type: Opaque
data:
  id: YWRtaW4K          #base64 인코딩한 값 (ex. admin)
  pwd: UEBzc3cwcmQK     #base64 인코딩한 값 (ex. password)

base64
admin
(값)  #이 값을 id와 pwd에 복사

kubectl describe secret mydata      #안보임
kubectl get secret mydata -o yaml   #보임 (인코딩된 값)

apiVersion: v1
kind: Pod
metadata:
  name: myweb-secret
spec:
  containers:
    - name: myweb
      image: ghcr.io/c1t1d0s7/go-myweb:alpine
      envFrom:
        - secretRef:
            name: mydata

apiVersion: v1
kind: Pod
metadata:
  name: myweb-env
spec:
  containers:
    - name: myweb
      image: ghcr.io/c1t1d0s7/go-myweb:alpine
      env:
        valueFrom:
          secretKeyRef:
            name: mydata 
            key: id

파일

apiVersion: v1
kind: Pod
metadata:
  name: myweb-sec-vol
spec:
  containers:
    - name: myweb
      image: ghcr.io/c1t1d0s7/go-myweb:alpine
      volumeMounts:
        - name: secvol
          mountPath: /secvol

  volumes:
    - name: secvol
      secret:
        secretName: mydata

Deployments (deploy)

Pod와 ReplicaSet에 대한 선언적 업데이트 제공

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myweb-deploy
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb:v1
          ports:
            - containerPort: 8080

Deployments에서 사용 가능한 스토리지

recreate

• 장점 셋업이 쉽다 애플리케이션은 완전히 갱신됨

• 단점 다운타임이 발생한다

ramped(rolling-update)

• 장점 무중단 24//7 버전이 천천히 배포 db쉽게 이동

• 단점 롤아웃/롤백이 시간이 걸림 다중api 지원이 어렵다 트래픽 컨트롤방법이 없다

blue/green

• 특징 recreate와 차이 - 리소스가 더 많이 필요하다 다운타임 최소화 비싸다

canary

• lb에 일정비율로 배포할 수 있는 기능이 있어야함

a/b testing

• browser,user-agent등의 정보를 통한 접속 분리 (client 구별)

shadow

• 고급 기술이 필요

apiVersion: v1
kind: Service
metadata:
  name: myweb-svc-lb
spec:
  type: LoadBalancer
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 8080

kubectl rollout status deploy myweb-deploy

kubectl rollout history deploy myweb-deploy

image 변경 시 replace, apply, edit, patch, set

kubectl set image deployments myweb-deploy myweb=ghcr.i
o/c1t1d0s7/go-myweb:v2.0 --record

--record: 명령을 히스토리에 저장

record를 붙여야 history에서 사유가 작성됨(change case)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myweb-deploy
  annotations:
    kubernetes.io/change-cause: "Change Go Myweb version from 3 to 4"
    ...

kubectl apply -f myweb-deploy.yaml

(apply 할때 레코드를 작성하면 history에서 변경 된 파일의 수정 내용을 모르지만 annotaion을 작성하면 알 수 있음) -단 annotaion 작성하면 record는 붙이지 않음

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myweb-deploy
  annotations:
    kubernetes.io/change-cause: "Change Go Myweb version from 3 to 4"
spec:
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb:v4.0
          ports:
            - containerPort: 8080

max surge

(default: 25%) replicas기본3개 서지1개 롤아웃 시 3+1 =4 개 파드가 생성 가능 기본값은 절대값 및 퍼센트로 지정가능

max unavailable

(default: 25%) 파드 삭제 개수 (rs는 지우지 않음 rollback을 위해)

minReadySeconds

최소대기시간 기본값:0 파드가 준비상태까지의 대기시간 설정

revisionHistoryLimit

기본값:10 히스토리 개수

TLS/SSL Termination with Ingress

SSL3.0과 TLS 1.0은 호환 가능 SSL은 취약점이 발견되어 사용하지 않음

client <-->LB<-->nginx pod https
      https   https
       <--------->
      end to end 방식

                  < Private networ >
           Esposed SSL
client <-> Termination <--> webservice
             Proxy
       https           http
      <---->
   이 구간만 암호화

Proxy 에서만 인증서 인증을 할 수 있음 webservice가 인증 받을 필요가 없음

비암호화 구간이 있어야 공격을 탐지할 수 있음 암호화 구간에서는 공격도 암호화가 되어 탐지가 어려움

암복호화가 메모리를 많이 사용함

ingress-tls-secret.yaml

apiVersion: v1
kind: Secret
metadata:
  name: ingress-tls-secret
type: kubernetes.io/tls
data:
  # base64 x509/nginx-tls.crt -w 0
  tls.crt: |
    LS0tLS1CRUd...
  # base64 x509/nginx-tls.key -w 0
  tls.key: |
    LS0tLS1CRUdJ...

myweb-rs.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myweb-rs
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
      env: dev
  template:
    metadata:
      labels:
        app: web
        env: dev
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb
          ports:
            - containerPort: 8080
              protocol: TCP

myweb-svc-np.yaml

apiVersion: v1
kind: Service
metadata:
  name: myweb-svc-np
spec:
  type: NodePort
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 8080

myweb-ing-tls.yaml

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myweb-ing-tls
spec:
  tls:
    - hosts:
        - '*.nip.io'
      secretName: ingress-tls-secret
  rules:
    - host: '*.nip.io'
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: myweb-svc-np
                port:
                  number: 80

curl -k https://192-168-100-100.nip.io

spec.volumes.*: 볼륨 유형

emptyDir

임시로 사용할 빈 볼륨, 파드 삭제 시 볼륨 같이 삭제 디스크 기반의 병합 종류와 같은 스크레치 공간 충돌로부터 복구하기위해 긴 계산을 검사점으로 지정 웹 서버 컨테이너가 데이터를 처리하는 동안 컨텐츠 매니저 컨테이너가 가져오는 파일을 보관 medium을 momery로 쓰면 램메모리 사용가능

apiVersion: v1
kind: Pod
metadata:
  name: myweb-pod
spec:
  containers:
    - name: myweb1
      image: httpd
      volumeMounts:
        - name: emptyvol
          mountPath: /empty
    - name: myweb2
      image: ghcr.io/c1t1d0s7/go-myweb:alpine
      volumeMounts:
        - name: emptyvol
          mountPath: /empty
  volumes:
    - name: emptyvol
      emptyDir: {}

kubectl create -f myweb-pod.yaml

kubectl exec -it myweb-pod -c myweb1 -- bash

> cd /empty
> touch a b c

kubectl exec -it myweb-pod -c myweb2 -- sh

> ls /empty

kubectl describe po myweb-pod  #같은 볼륨을 서로 공유

gitRepo(사용 중지) --> initContainer(초기화 컨테이너)

pod 생성 시 딱 1번만 실행되고 종료됨

https://kubernetes.io/ko/docs/concepts/workloads/pods/init-containers/

apiVersion: v1
kind: Pod
metadata:
  name: init-pod
spec:
  initContainers:
    - name: gitpull
      image: alpine/git
      args:
        - clone
        - -b
        - v2.18.1
        - https://github.com/kubernetes-sigs/kubespray.git
        - /repo
      volumeMounts:
        - name: gitrepo
          mountPath: /repo
  containers:
    - name: gituse
      image: busybox
      args:
        - tail
        - -f
        - /dev/null
      volumeMounts:
        - name: gitrepo
          mountPath: /kube
  volumes:
    - name: gitrepo
      emptyDir: {}

hostPath

/mnt/web_contents/index.html

<h1> Hello hostPath </h1>

참고 로컬 스토리지: 다른 호스트에 스토리지 볼륨을 제공할 수 X

• emptyDir
• hostPath
• gitRepo
• local

vi myweb-rs-hp.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myweb-rs-hp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: myweb
          image: httpd
          volumeMounts:
            - name: web-contents
              mountPath: /usr/local/apache2/htdocs/
      volumes:
        - name: web-contents
          hostPath:
            type: Directory
            path: /web_contents

sudo mkdir /web_contents

sudo echo :hellohostPath" | sudo tee /web_contents/index.html

cat /web_contents/index,html

kubectl create -f myweb-rs-hp.yaml

kubectl get rs,po -o wide

node1은 생성되지만 node2,3은 생성되지 않는걸 확인 할 수 있음

emptyDir, hostPath는 local storage임 network storage가 아님

ssh node2 sudo kidir /seb_contents
ssh node2 echo "hello hostPath" | sudo tee /web_contents/index.html
ssh node3 sudo kidir /seb_contents
ssh node3 echo "hello hostPath" | sudo tee /web_contents/index.html

kubectl delete po myweb-   #생성안된 파드 삭제

kubectl get po

PV & PVC

• PersistentVolume: 스토리지 볼륨 정의
• PersistentVolumeClaim: PV를 요청

pv, pvc 예제

Pod

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
    - name: mypod
      image: httpd
      volumeMounts:
        - name: myvol
          mountPath: /tmp
  volumes:
    - name: myvol
      persistentVolumeClaim:
        name: mypvc

PVC

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mypvc
spec:
  volumeName: mypv
  ...

PV

apiVersion: v1
kind: PersistentVolume
metadata:
  name: mypv
spec:
  hostPath:
    path: /web_contents
    type: DirectoryOrCreate

PV, PVC 생명주기

PV <--1:1--> PVC

1. 프로비저닝
2. 바인딩
3. 사용
4. 회수/반환(Reclaim)
   • Retain: 보존 - PV를 삭제하지 않음(Release <- PVC가 연결 X)
   • Delete: 삭제 - PV를 삭제 / 실제 스토리지 내용 삭제
   • Recycle: 재사용(X) - 실제 스토리지 내용을 비우고, PV를 사용 가능한 상태(Available)

접근 모드(Access Mode)

• ReadWriteOnce: RWO
• ReadWriteMany: RWX
• ReadOnlyMant: ROW

NFS를 사용한 정적 프로비저닝(Static Provision)

node1: NFS 서버

sudo apt install nfs-kernel-server -y

sudo mkdir /nfsvolume
echo "<h1> Hello NFS Volume </h1>" | sudo tee /nfsvolume/index.html

sudo chown -R www-data:www-data /nfsvolume

/etc/exports

/nfsvolume 192.168.100.0/24(rw,sync,no_subtree_check,no_root_squash)

sudo systemctl restart nfs-kernel-server
systemctl status nfs-kernel-server

active(exited) 상태 확인

node1, node2, node3

sudo apt install nfs-common -y 

또는

ansible all -i ~/kubespray/inventory/mycluster/inventory.ini -m apt -a 'name=nfs-common' -b

PV

apiVersion: v1
kind: PersistentVolume
metadata:
  name: mypv
spec:
  accessModes:
    - ReadWriteMany
  capacity:
    storage: 1G
  persistentVolumeReclaimPolicy: Retain
  nfs:
    path: /nfsvolume
    server: 192.168.100.100

PVC

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mypvc
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 1G
  storageClassName: '' # For Static Provisioning
  volumeName: mypv

RS

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myweb-rs
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: myweb
          image: httpd
          volumeMounts:
            - name: myvol
              mountPath: /usr/local/apache2/htdocs
      volumes:
        - name: myvol
          persistentVolumeClaim:
            claimName: mypvc

SVC

apiVersion: v1
kind: Service
metadata:
  name: myweb-svc-lb
spec:
  type: LoadBalancer
  ports:
    - port: 80
      targetPort: 80
  selector:
    app: web

안될 시 (권한변경) node1으로 이동 ls -ld /nfsvolume sudo chown nobody:hogroup -R /nfsvolume sudo chmod 770 -R /nfsvolume sudo exportfs -arv

파드가 삭제되고 생성되어도 동일한 pvc에 연결됨 pvc와 pv 연결된 상태에서 pv는 삭제 안됨 릴리즈 상태의 pv에 연결 안됨

동적 프로비저닝

Vagrant 스냅샷: 스냅샷 생성: vagrant snapshot save before-rook 스냅샷 복구: vagrant snapshot restore before-rook

NFS Dynamic Provisioner 구성

https://github.com/kubernetes-sigs/nfs-subdir-external-provisioner

git clone https://github.com/kubernetes-sigs/nfs-subdir-external-provisioner.git

cd nfs-subdir-external-provisioner/deploy

kubectl create -f rbac.yaml

deployment.yaml

...
          env:
            - name: PROVISIONER_NAME
              value: k8s-sigs.io/nfs-subdir-external-provisioner
            - name: NFS_SERVER
              value: 192.168.100.100
            - name: NFS_PATH
              value: /nfsvolume
      volumes:
        - name: nfs-client-root
          nfs:
            server: 192.168.100.100
            path: /nfsvolume

kubectl create -f deployment.yaml

kubectl create -f class.yaml

mypvc-dynamic.yaml

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mypvc-dynamic
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 1G
  storageClassName: 'nfs-client'  #변경

kubectl create -f mypvc-dynamic.yaml

sudo ls -l /nfsvolume
sudo ls -l /nfsvolume/default~~

echo "<h1> Hello NFS Dynamic Provision </h1>" | sudo tee /nfsvolume/XXX/index.html

myweb-rs-dynamic.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myweb-rs
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: myweb
          image: httpd
          volumeMounts:
            - name: myvol
              mountPath: /usr/local/apache2/htdocs
      volumes:
        - name: myvol
          persistentVolumeClaim:
            claimName: mypvc-dynamic

kubectl create -f myweb-rs-dynamic.yaml

기본 스토리지 클래스

~/nfs-subdir-external-provisioner/deploy/class.yaml

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-client
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"  #추가
provisioner: k8s-sigs.io/nfs-subdir-external-provisioner # or choose another name, must match deployment's env PROVISIONER_NAME'
parameters:
  archiveOnDelete: "false"

kubectl apply -f class.yaml

kubectl get sc

NAME                   ...
nfs-client (default)   ...

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mypvc-dynamic
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 1G

Default Storage를 지정해두면 vi mypvc.yaml 에서 storageClassName을 적지 않아도 Default StorageClass로 지정이됨

Metallb

~/kubespray/inventory/mycluster/group_vars/k8s-cluster/addons.yml

...
139 metallb_enabled: true
140 metallb_speaker_enabled: true
141 metallb_ip_range:
142   - "192.168.100.240-192.168.100.249"
...
168 metallb_protocol: "layer2"
...

~/kubespray/inventory/mycluster/group_vars/k8s-cluster/k8s-cluster.yml

129 kube_proxy_strict_arp: true

Niginx Ingress Controller

~/kubespray/inventory/mycluster/group_vars/k8s-cluster/addons.yml

 93 ingress_nginx_enabled: true

metrics-server

~/kubespray/inventory/mycluster/group_vars/k8s-cluster/addons.yml

 16 metrics_server_enabled: true

적용

ansible-playbook -i inventory/mycluster/inventory.ini cluster.yml -b

Service Type

1) nodeport 클러스터 외부 2) loadbalancer 클러스터 외부 3) cluster ip 클러스터 내부

Service - ClusterIP

myweb-svc.yaml

apiVersion: v1
kind: Service
metadata:
  name: myweb-svc
spec:
  selector: # 파드 셀렉터
    app: web
  ports:
    - port: 80 # 서비스 포트
      targetPort: 8080 # 타켓(파드 포트)

port 클라이언트가 접속하는 포트 targetport 컨테이너 파드 접속포트

kubectl create -f .

kubectl get svc myweb-svc

kubectl describe svc myweb-svc

kubectl get endpoint myweb-svc

kubectl run nettool -it --image ghcr.io/c1t1d0s7/network-multitool

> curl x.x.x.x(서비스 리소스의 ClusterIP)
> host myweb-svc
> curl myweb-svc

curl 확인을 위해 apt update; apt install curl curl x.x.x.x (10.233.28.39)

Session Affinity

세션 고정 default 값은 none (ClientIP 변경가능) meyweb-svc-ses.yaml

apiVersion: v1
kind: Service
metadata:
  name: myweb-svc-ses
spec:
  type: ClusterIP
  sessionAffinity: ClientIP
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 8080

Named Port

myweb-rs-named.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myweb-rs-named
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
      env: dev
  template:
    metadata:
      labels:
        app: web
        env: dev
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb
          ports:
            - containerPort: 8080
              protocol: TCP
              name: web8080                #콘테이너 네임을 적을 수 있음

myweb-svc-named.yaml

apiVersion: v1
kind: Service
metadata:
  name: myweb-svc-named
spec:
  type: ClusterIP
  selector:
    app: web
  ports:
    - port: 80
      targetPort: web8080

Multi Port

myweb-rs-multi.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myweb-rs-multi
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
      env: dev
  template:
    metadata:
      labels:
        app: web
        env: dev
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb
          ports:
            - containerPort: 8080
              protocol: TCP
            - containerPort: 8443
              protocol: TCP

http 80 https 443

myweb-svc-multi.yaml

apiVersion: v1
kind: Service
metadata:
  name: myweb-svc-multi
spec:
  type: ClusterIP
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 8080
      name: http
    - port: 443
      targetPort: 8443
      name: https

Service Discovery

환경 변수를 이용한 SD

모든 파드는 실행 시 현재 시점의 서비스 목록을 환경 변수 제공

# env | grep MYWEB
MYWEB_SVC_PORT_80_TCP_PORT=80
MYWEB_SVC_PORT_80_TCP_PROTO=tcp
MYWEB_SVC_PORT_80_TCP=tcp://10.233.3.182:80
MYWEB_SVC_SERVICE_HOST=10.233.3.182
MYWEB_SVC_PORT=tcp://10.233.3.182:80
MYWEB_SVC_SERVICE_PORT=80
MYWEB_SVC_PORT_80_TCP_ADDR=10.233.3.182

DNS를 이용한 SD

kube-dns(coredns-X 파드)

Service 생성하면 해당 이름으로 FQDN을 DNS 서버에 등록

[서비스 이름].[네임스페이스].[오브젝트 타입].[도메인]

myweb-svc.default.svc.cluster.local

host myweb-svc host myweb-svc.default (nameSpace까지는 써주는거 권장)

마지막 점 (RootHint) myweb-svc.default.svc.cluster.local (.) <-

nodelocal DNS

nodelocal DNS 캐시 사용 Pod --dns--> 169.254.25.10(node-cache): DNS Cache Server --> coredns SVC(kube-system NS) -> coredns POD

nodelocal DNS 캐시 사용 X Pod --dns--> coredns SVC(kube-system NS) -> coredns POD

Service - NodePort

svc.spec.type

• ClusterIP: 클러스터 내에서 사용하는 LB
• NodePort: 클러스터 외부에서 접근하는 포인트
• LoadBalancer: 클러스터 외부에서 접근하는 LB

system port 01023 (root권한) registered port 102449151 dynamic/private port 49152~65535 (client사용)

NodePort의 범위: 30000-32767

myweb-svc-np.yaml

apiVersion: v1
kind: Service
metadata:
  name: myweb-svc-np
spec:
  type: NodePort
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 31313

nodePort = nodePort + ClusterIP nodePort를 지정안하면 자동으로 지정

Service - LoadBalancer

LoadBalancer : L4 LB (MetalLB) ingress : L7 LB (Nginx)

myweb-svc-lb.yaml

apiVersion: v1
kind: Service
metadata:
  name: myweb-svc-lb
spec:
  type: LoadBalancer
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 31313

Kubernetes는 외부에 LB를 생성할 수 없음 but, METALLB 를 사용하면 가능 (내부 pod을 이용하여)

Metallb - Addon

~/kubespray/inventory/mycluster/group_vars/k8s-cluster/addons.yml

...
139 metallb_enabled: true
140 metallb_speaker_enabled: true
141 metallb_ip_range:
142   - "192.168.100.240-192.168.100.249"
...
168 metallb_protocol: "layer2"
...

~/kubespray/inventory/mycluster/group_vars/k8s-cluster/k8s-cluster.yml

129 kube_proxy_strict_arp: true

ansible-playbook -i inventory/mycluster/inventory.ini cluster.yml -b

LoadBalancer = (외부)LB + NP + ClusterIP

MetalLb는 2가지 모드가 있음

1. Layer2 가 default값 - 소규모
2. BGP (L3 SW를 사용) - 대규모

(METALLB 참고링크) https://metallb.universe.tf/

Service - ExternalName

클러스터 내부에서 클러스터 외부의 특정 서비스에 접속하기 위해 DNS CNAME을 설정

apiVersion: v1
kind: Service
metadata:
  name: weather-ext-svc
spec:
  type: ExternalName
  externalName: www.naver.com

kubectl replac -f weather-ext-svc.yaml   #[네임(주소)이 변경 되었을때]

curl -s 'wttr.in/Seoul' curl -s 'wttr.in/Seoul?format=1' curl -s 'wttr.in/Seoul?format=2' (서울날씨가 뜸!)

Ingress

L7 LB = ALB

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myweb-ing
spec:
  rules:
    - host: '*.encore.xyz'
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: myweb-svc-np
                port:
                  number: 80

도메인 없이 테스트 하는 법

방법1

curl --resolve www.encore.xyz:80:192.168.100.100 http://www.encore.xyz

방법2 /etc/hosts

...
192.168.100.100 www.encore.xyz  #빈곳에 작성

curl http://www.encore.xyz

방법3

https://nip.io/ https://sslip.io/

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myweb-ing
spec:
  rules:
    - host: '*.nip.io'
    ...

kubectl replace -f myweb-ing.yaml

curl http://192-168-100-100.nip.io

인그레스 예제

hello:one 이미지 Dockerfile

FROM httpd
COPY index.html /usr/local/apache2/htdocs/index.html

index.html

<h1> Hello One </h1>

hello:two 이미지 Dockerfile

FROM httpd
COPY index.html /usr/local/apache2/htdocs/index.html

index.html

<h1> Hello Two </h1>

docker image build X/hello:one
docker image build X/hello:two

docker login

docker push X/hello:one
docker push X/hello:two

RS one-rs.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: one-rs
spec:
  replicas: 3
  selector:
    matchLabels:
      app: hello-one
  template:
    metadata:
      labels:
        app: hello-one
    spec:
      containers:
        - name: hello-one
          image: c1t1d0s7/hello:one
          ports:
            - containerPort: 80
              protocol: TCP

two-rs.yaml

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: two-rs
spec:
  replicas: 3
  selector:
    matchLabels:
      app: hello-two
  template:
    metadata:
      labels:
        app: hello-two
    spec:
      containers:
        - name: hello-two
          image: c1t1d0s7/hello:two
          ports:
            - containerPort: 80
              protocol: TCP

one-svc-np.yaml

apiVersion: v1
kind: Service
metadata:
  name: one-svc-np
spec:
  type: NodePort
  selector:
    app: hello-one
  ports:
    - port: 80
      targetPort: 80

two-svc-np.yaml

apiVersion: v1
kind: Service
metadata:
  name: two-svc-np
spec:
  type: NodePort
  selector:
    app: hello-two
  ports:
    - port: 80
      targetPort: 80

hello-ing.yaml

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: hello-ing
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: / # URL 재작성, /one -> /, /two -> /
spec:
  rules:
    - host: '*.nip.io'
      http:
        paths:
          - path: /one
            pathType: Prefix
            backend:
              service:
                name: one-svc-np
                port:
                  number: 80
          - path: /two
            pathType: Prefix
            backend:
              service:
                name: two-svc-np
                port:
                  number: 80

kubectl create -f .

Readiness Probe

파드의 헬스체크를 통해 서비스의 엔드포인트 리소스에 타겟 등록

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myweb-rs
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
      env: dev
  template:
    metadata:
      labels:
        app: web
        env: dev
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb:alpine
          ports:
            - containerPort: 8080
              protocol: TCP
          readinessProbe:
            exec:
              command:
                - ls
                - /tmp/ready

apiVersion: v1
kind: Service
metadata:
  name: myweb-svc-lb
spec:
  type: LoadBalancer
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 8080

kubectl create -f .

watch -n1 -d kubectl get po,svc,ep

kubectl exec <POD> -- touch /tmp/ready

Pod 상태

• Pending: 스케줄링되기 전, 이미지 받기 전, 컨테이너가 준비 되기 전
• Running: 컨테이너가 실행 중, 실행 전, 재시작 중
• Succeed: 정상 종료 (0)
• Failed: 비정상 종료 (!0)
• Unknown: 노드의 통신 문제로 상태 알 수 없음

Container 상태

• Waiting: 이미지 받기 전, 볼륨 연결 되기 전
• Running: 실행 중
• Terminated: 종료

재시작 정책

kubectl explain pod.spec.restartPolicy

• pod.spec.restartPolicy
  • Always(기본)
  • OnFailure
  • Never

실시간 보기

#(상태가 변할때만 보임) - 여러개 지정 불가
kubectl get pods --watch

#(시간별로 보기) - 여러개 지정가능
watch -n1 -d kubectl get pods

지수 백오프

• 파드 실패시 재시작 정책에 의해 재시작을 하게됨
  • 재시작 시간 10, 20, 40, 80 ... 300 초 까지 유예기간

컨테이너 프로브

프로브 종류

• linveness: 애플리케이션 실행/작동 여부
• readiness
• startup: 애플리케이션이 시작 되었는지 확인, 성공하지 않으면 나머지 프로브 비활성화

프로브 메커니즘

• httpGet
  • Web, WebApp
  • 응답 코드 2XX, 3XX
• tcpSocket
  • 해당 포트 TCP 연결
• grpc
  • grcp 프로토콜 연결
• exec
  • 명령 실행
  • 종료 코드 0@

HTTP 응답코드 1xx 정보 2xx 성공 3xx 리디렉션 4xx 클라이언트 오류 5xx 서버오류

프로브 결과

• success
• failuer
• unknown

pods.spec.containers.livenessProbe

• exec
• httpGet
• tcpSocket
• periodSeconds: 프로브 주기
• failureThreshold: 실패 임계값
• successThreshold: 성공 임계값
• initialDelaySecond: 프로브 유예 기간
• timeoutSeconds: 프로브 타임아웃

Workload Resource = Controller

ReplicationController

ReplicationController (rc) :파드가 너무 많으면 추가적인 파드를 제거함 너무 적으면 파드를 시작함

kubectl explain rc.spec.template

pod.metadata.* = rc.spec.metadata.* pod.spec.* = rc.spec.template.spec.*

myweb-rc.yaml

apiVersion: v1
kind: ReplicationController
metadata:
  name: myweb-rc
spec:
  replicas: 3
  selector:
    app: web
# Pod Configure
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb
          ports:
            - containerPort: 8080
              protocol: TCP

파일을 이용한 rc 생성

kubectl create -f myweb-rc.yaml

rc 확인

watch kubectl get rc,pods --show-labels -o wide

NAME                 READY   STATUS    RESTARTS   AGE   LABELS
pod/myweb-rc-7m4v7   1/1     Running   0          29m   app=web
pod/myweb-rc-7s4vp   1/1     Running   0          78m   app=web
pod/myweb-rc-jtq7d   1/1     Running   0          78m   app=web

rc label 변경

kubectl label pod myweb-rc-jtq7d app=db --overwrite

kubectl label pod myweb-rc-jtq7d app=web --overwrite

RC 스케일링

명령형 커맨드

kubectl scale rc myweb-rc --replicas=5

명령형 오브젝트 구성

kubectl replace -f myweb-rc.yaml

yaml파일 고치고 create 대신 replace (단, template 정보는 수정해도 변경이 되지않음 -pod 만들때 최초에 적용)

kubectl patch -f myweb-rc.yaml -p '{"spec": {"replicas": 3}}'
kubectl patch rc myweb-rc.yaml --patch-file replicas.json

replicas.json

{"spec": {"replicas": 3}}

kubectl edit -f myweb-rc.yaml
kubectl edit rc myweb-rc
kubectl edit rc/myweb-rc

선언형 오브젝트 구성

kubectl apply -f myweb-rc.yaml

ReplicaSets

ReplicationController -> ReplicaSets rc와 rs는 거의 유사하지만 matchExpressions 이 추가됨

machLabels 사용 (rc와 유사)

apiVersion: apps/v1
kind: ReplicaSets
metadata:
  name: myweb-rs
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
      env: dev
  template:
    metadata:
      labels:
        app: web
        env: dev
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb
          ports:
            - containerPort: 8080
              protocol: TCP

matchExpressions 사용 (자기영역을 잘 셀렉팅하여 관리함)

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myweb-rs-set
spec:
  replicas: 3
  selector:
    matchExpressions:
      - key: app
        operator: In
        values: 
          - web
      - key: env
        operator: Exists
  template:
    metadata:
      labels:
        app: web
        env: dev
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb
          ports:
            - containerPort: 8080
              protocol: TCP

DaemonSets

: 모든 노드의 파드를 실행 노드가 추가되면 파드도 추가됨 노드가 제거되면 파드는 가비지로 수집됨 데몬셋을 삭제하면 데몬셋이 생성한 파드들이 정리

주용도 agent app을 보조하거나 infra유지보수관리

노드마다 하나씩 파드 배치

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: myweb-ds
spec:
  selector:
    matchExpressions:
      - key: app
        operator: In
        values:
          - myweb
      - key: env
        operator: Exists
  template:
    metadata:
      labels:
        app: myweb
        env: dev
    spec:
      containers:
        - name: myweb
          image: ghcr.io/c1t1d0s7/go-myweb
          ports:
            - containerPort: 8080
              protocol: TCP

cd ~/kubespray

노드 제거

ansible-playbook -i inventory/mycluster/inventory.ini remove-node.yml -b --extra-vars="node=node3" --extra-vars reset_nodes=true

노드 추가

ansible-playbook -i inventory/mycluster/inventory.ini scale.yml -b

노드 추가 및 제거 참고링크 https://kubespray.io/#/docs/getting-started

Jobs

: 성공적으로 종료될 때까지 계속해서 파드를 실행 시작-->완료

apiVersion: batch/v1
kind: Job
metadata:
  name: mypi
spec:
  template:
    spec:
      containers:
        - image: perl  
          name: mypi
          command: ["perl",  "-Mbignum=bpi", "-wle", "print bpi(2000)"]
      restartPolicy: OnFailure

tip. 명령어 작성 시 esc+. 을 치면 마지막 아규먼트, 옵션이 나옴

잡 컨트롤러의 레이블

파드 템플릿의 레이블 / 잡 컨트롤러의 레이블 셀렉터는 지정하지 않는다. -> 잘못된 매핑으로 기존의 파드를 종료하지 않게 하기 위함

파드의 종료 및 삭제

job.spec.activeDeadlineSeconds: 애플리케이션이 실행될 수 있는 시간 지정 job.spec.ttlSecondsAfterFinished: 컨트롤러 및 파드 삭제

apiVersion: batch/v1
kind: Job
metadata:
  name: mypi
spec:
  template:
    spec:
      containers:
        - image: perl
          name: mypi
          command: ["perl",  "-Mbignum=bpi", "-wle", "print bpi(2000)"]
      restartPolicy: OnFailure
  ttlSecondsAfterFinished: 10

작업의 병렬 처리

job.spec.completions: 완료 횟수 job.spec.parallelism: 병렬 개수 completions 수 >= parallelism 수

apiVersion: batch/v1
kind: Job
metadata:
  name: mypi-para
spec:
  completions: 3
  parallelism: 3
  template:
    spec:
      containers:
        - image: perl
          name: mypi
          command: ["perl",  "-Mbignum=bpi", "-wle", "print bpi(1500)"]
      restartPolicy: OnFailure

일시중지

kubectl edit jod mypi

suspend를 true로 변경하여 일시중지 가능 (default 값은 false)

kubectl get po -A로 보는 목록중 뒤에 -node 가 붙어있는 pod들은 static pod이며 kubelet이 관리함

CronJob

: 주기적으로 동작 시킴

kubectl explain cj --api-version=batch/v1beta1 (다른버전 상세 확인) 1.8 ~ 1.20 -> v1beta1 1.21 -> v1

apiVersion: batch/v1
kind: CronJob
metadata:
  name: sleep-cj
spec:
  schedule: "* * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
            - name: sleep
              image: ubuntu
              command: ["sleep", "80"]
          restartPolicy: OnFailure
  #concurrencyPolicy: ( Allow | Forbid | Replace )

cj.spec.concurrencyPolicy

• Allow: 동시 작업 가능
• Forbid: 동시 작업 금지(이전 작업이 계속 실행 됨)
• Replace: 교체(이전 작업은 종료되고 새로운 작업 실행)

100회이상의 일정이 누락되면 잡을 실행하지않고 에러 로그를 남김

https://kubernetes.io/ko/docs/concepts/workloads/pods/

파드: 컨테이너의 모음 쿠버네티스가 관리할 수 있는 가장 작은 워크로드는 파드

파드 생성 및 관리

명령형 커맨드로 파드 생성

kubectl run myweb --image httpd

파드 목록 확인

kubectl get pods

특정 파드 확인

kubectl get pods myweb

파드 상세 정보

kubectl get pods -o wide

kubectl get pods -o yaml

kubectl get pods -o json

kubectl describe pods myweb

애플리케이션 로그

kubectl logs myweb

파드 삭제

kubectl delete pods myweb

YAML 파일로 파드 정의

myweb.yaml

apiVersion: v1
kind: Pod 
metadata:
  name: myweb
spec:
  containers:
    - name: myweb
      image: httpd
      ports:
        - containerPort: 80
          protocol: TCP

kubectl explain pods

파일을 이용한 pods 생성

kubectl create -f myweb.yaml

파일을 이용한 pods 확인

kubectl get -f myweb.yaml

kubectl describe -f myweb.yaml

파일을 이용한 pods 삭제

kubectl delete -f myweb.yaml

kubectl 명령의 서브 명령

• create
• get
• describe
• logs
• delete
• replace
• patch
• apply
• diff

파드 디자인

• 단일 컨테이너: 일반 적인 형태
• 멀티 컨테이너: 메인 애플리케이션이 존재 매인 애플리케이션 기능을 확장 하기 위한 컨테이너를 배치

사이드카 패턴 https://kubernetes.io/blog/2015/06/the-distributed-system-toolkit-patterns/

• sidecar: 기능의 확장
• ambassador: 프록시/LB
• adpator: 출력의 표준

포트 및 포트 포워딩

테스트 & 디버깅 목적

kubectl port-forward pods/myweb 8080:80

이름 & UID

이름: 네임스페이스 유일 UID: 클러스터에서 유일

Namespace

리소스를 분리

• 서비스 별
• 사용자 별
• 환경: 개발, 스테이징, 프로덕션

서비스: DNS 이름이 분리되는 용도 RBAC: 권한을 NS에 설정

https://kubernetes.io/ko/docs/concepts/overview/working-with-objects/namespaces/

kubectl get namespaces

• kube-system: Kubernetes의 핵심 컴포넌트
• kube-public: 모든 사용자가 읽기 권한
• kube-node-lease: 노드의 HeartBeat 체크를 위한 Lease 리소스가 존재
• default: 기본 작업 공간 namespace(ns) 생성

  kubectl create ns developments

  ns 삭제

  kubectl delete ns developments

  ns 확인

  kubectl get pods -A | --all-namespaces

  name 옵션을 통한 확인

  kubectl get pods -n kube-system

ns-dev.yaml

apiVersion: v1
kind: Namespace
metadata:
  name: dev

kubectl create -f ns-dev.yaml

myweb-dev.yaml

apiVersion: v1
kind: Pod
metadata:
  name: myweb
  namespace: dev
spec:
  containers:
    - name: myweb
      image: httpd
      ports:
        - containerPort: 80
          protocol: TCP          

kubectl create -f myweb-dev.yaml

kubectl delete -f myweb-dev.yaml

Label & LabelSelector

https://kubernetes.io/ko/docs/concepts/overview/working-with-objects/labels/ https://kubernetes.io/ko/docs/concepts/overview/working-with-objects/common-labels/

Label

레이블 확인

kubectl get pods --show-labels

kubectl get pods X -o yaml

kubectl describe pods X

레이블 관리

kubectl label pods myweb APP=apache

kubectl label pods myweb ENV=developments

kubectl label pods myweb ENV=staging

overwrite 옵션 사용 (덮어쓰기)

kubectl label pods myweb ENV=staging --overwirte

kubectl label pods myweb ENV-

LabelSelector

• 검색
• 리소스 간 연결

일치성(equality base)

• =
• ==
• !=

kubectl get pods -l APP=nginx
kubectl get pods -l APP==nginx

kubectl get pods -l 'APP!=nginx'

집합성(set base)

• in
• notin
• exists: 키만 매칭
  • kubectl get pods -l 'APP'
• doesnotexists: 키 제외 매칭
  • kubectl get pods -l '!APP'

Annotations

레이블과 비슷 비 식별 메타데이타 애플리케이션이 해당 메타데이터를 참조할 수 있음 -> 애플리케이션 작동 변경

명령형 커맨드

kubectl annotate pods myweb created-by=Jang

kubectl annotate pods myweb created-by=Kim --overwrite

kubectl annotate pods myweb created-by-

YAML

apiVersion: v1
kind: Pod
metadata:
  name: myweb-label-anno
  labels:
    APP: apache
    ENV: staging
  annotations:
    Created-by: Jang
spec:
  containers:
    - name: myweb
      image: httpd
      ports:
        - containerPort: 80
          protocol: TCP

Ubuntu 패키지 저장소 변경 sed -i 's/security.ubuntu.com/mirror.kakao.com/g' /etc/apt/sources.list sed -i 's/archive.ubuntu.com/mirror.kakao.com/g' /etc/apt/sources.list sudo apt update

https://kubernetes.io/ko/releases/version-skew-policy/

1. kube-apiserver
2. kube-controller-manager, kube-cloud-controller-manage, kube-scheduler
3. kubelet(Control Plane -> Worker Node)
4. kube-proxy(Control Plane -> Worker Node)

Control Plane(api -> cm, ccm, sched -> let,proxy) --> Work Node(let, proxy)

kubeadm 업그레이드

1. Control Plane의 kubeadm 업그레이드
2. Control Plane의 kubeadm으로 api, cm, sched 업그레이드
3. Control Plane의 kubelet, kubectl 업그레이드
4. Work Node의 kubeadm 업그레이드
5. Work Node의 kubeadm으로 업그레이드
6. Work Node의 kubelet, kubectl 업그레이드

Control Plane

sudo apt-mark unhold kubeadm

sudo apt update

sudo apt upgrade kubeadm=1.22.9-00 -y

kubeadm version

sudo apt-mark hold kubeadm

sudo kubeadm upgrade plan

sudo kubeadm upgrade apply v1.22.9

sudo apt-mark unhold kubelet kubectl

sudo apt upgrade kubectl=1.22.9-00 kubelet=1.22.9-00 -y

sudo apt-mark hold kubelet kubectl

kubelet --version
kubectl version

drain 작업

sudo systemctl daemon-reload
sudo systemctl restart kubelet

uncordon 작업

systemctl status kubelet

Work Node

sudo apt-mark unhold kubeadm

sudo apt update

sudo apt upgrade kubeadm=1.22.9-00 -y

kubeadm version

sudo apt-mark hold kubeadm

`

sudo kubeadm upgrade node

drain 작업

sudo apt-mark unhold kubelet kubectl

sudo apt upgrade kubectl=1.22.9-00 kubelet=1.22.9-00 -y

sudo apt-mark hold kubelet kubectl

kubelet --version
kubectl version

sudo systemctl daemon-reload
sudo systemctl restart kubelet

uncordon 작업

Kubespray

https://kubernetes.io/ko/docs/setup/production-environment/tools/kubespray/ https://kubespray.io/#/ https://github.com/kubernetes-sigs/kubespray

Control Plane 1 Work Node 3(1 Control Plan + 2 Woker Node)

CPU: 2, Memory 3GB

~/vagrant/k8s

Vagrant.configure("2") do |config|
    # Define VM
    config.vm.define "k8s-node1" do |ubuntu|
        ubuntu.vm.box = "ubuntu/focal64"
        ubuntu.vm.hostname = "k8s-node1"
        ubuntu.vm.network "private_network", ip: "192.168.100.100"
        ubuntu.vm.provider "virtualbox" do |vb|
            vb.name = "k8s-node1"
            vb.cpus = 2
            vb.memory = 3000
        end
    end
    config.vm.define "k8s-node2" do |ubuntu|
        ubuntu.vm.box = "ubuntu/focal64"
        ubuntu.vm.hostname = "k8s-node2"
        ubuntu.vm.network "private_network", ip: "192.168.100.101"
        ubuntu.vm.provider "virtualbox" do |vb|
            vb.name = "k8s-node2"
            vb.cpus = 2
            vb.memory = 3000
        end
    end
    config.vm.define "k8s-node3" do |ubuntu|
        ubuntu.vm.box = "ubuntu/focal64"
        ubuntu.vm.hostname = "k8s-node3"
        ubuntu.vm.network "private_network", ip: "192.168.100.102"
        ubuntu.vm.provider "virtualbox" do |vb|
            vb.name = "k8s-node3"
            vb.cpus = 2
            vb.memory = 3000
        end
    end

    config.vm.provision "shell", inline: <<-SHELL
      sed -i 's/PasswordAuthentication no/PasswordAuthentication yes/g' /etc/ssh/sshd_config
      sed -i 's/archive.ubuntu.com/mirror.kakao.com/g' /etc/apt/sources.list
      sed -i 's/security.ubuntu.com/mirror.kakao.com/g' /etc/apt/sources.list
      systemctl restart ssh
    SHELL
end

1. SSH 키 생성 및 복사

ssh-keygen

ssh-copy-id vagrant@192.168.100.100
ssh-copy-id vagrant@192.168.100.101
ssh-copy-id vagrant@192.168.100.102

2. kubespray 소스 다운로드

cd ~

git clone -b v2.18.1 https://github.com/kubernetes-sigs/kubespray.git

cd kubespray

3. ansible, netaddr, jinja 등 패키지 설치

sudo apt update
sudo apt install python3-pip -y

sudo pip3 install -r requirements.txt

4. 인벤토리 구성

cp -rpf inventory/sample/ inventory/mycluster

inventory/mycluster/inventory.ini

[all]
node1 ansible_host=192.168.100.100 ip=192.168.100.100
node2 ansible_host=192.168.100.101 ip=192.168.100.101
node3 ansible_host=192.168.100.102 ip=192.168.100.102

[kube_control_plane]
node1

[etcd]
node1

[kube_node]
node1
node2
node3

[calico_rr]

[k8s_cluster:children]
kube_control_plane
kube_node
calico_rr

5. 변수 설정

(kubespray 변수 정의 및 정리 - https://kubespray.io/#/docs/vars)

inventory/mycluster/group_vars

6. 플레이북 실행

ansible all -m ping -i inventory/mycluster/inventory.ini

ansible-playbook -i inventory/mycluster/inventory.ini cluster.yml -b 

7. 검증

mkdir ~/.kube
sudo cp /etc/kubernetes/admin.conf ~/.kube/config
sudo chown vagrant:vagrant ~/.kube/config

kubectl get nodes

kubectl get pods -A

Kubernetes Objects

https://kubernetes.io/ko/docs/concepts/overview/working-with-objects/kubernetes-objects/

오브젝트 종류

kubectl api-resouces

• Label/LabelSelector

• Workload

  • Pod
  • Controller
    • ReplicationController
    • ReplicaSets
    • DaemonSets
    • Jobs
    • CronJobs
    • Deployments
    • StatefulSets
    • HorizontalPodAutoscaler

• Network

  • Service
  • Endpoints
  • Ingress

• Storage

  • PersistentVolume
  • PersistentVolumeClaim
  • ConfigMap
  • Secret

• Authentication

  • ServiceAccount
  • RBAC
    • Role
    • ClusterRole
    • RoleBinding
    • ClusterRoleBinding

• Resource Isolation

  • Namespaces

• Resource Limits

  • Limits
  • Requests
  • ResourceQuota
  • LimitRange

• Scheduling

  • NodeName
  • NodeSelector
  • Affinity
    • Node Affinity
    • Pod Affinity
    • Pod Anti Affinity
  • Taints/Tolerations
  • Drain/Cordon

오브젝트의 버전

https://kubernetes.io/ko/docs/reference/using-api/#api-%EA%B7%B8%EB%A3%B9

kubectl api-versions

apps/v1

• apps: 그룹
• v1: 버전

그룹이 없는 api는 core 그룹

• Stable
  • vX
  • v1, v2
  • 안정화된 버전
• Beta
  • v1betaX, v2betaX
  • 충분히 검증 오류 X
  • 버전이 올라가되면 기능 변경이 있을 수 있음
    • downtime 발생할 수도 있음: 특정 기능을 사용하기 위해 재시작
  • Mission Critical
• Alpha
  • v1alphaX, v2alphaX
  • 기본 비활성화
  • 개발 중인 API

Alpha -> Beta -> Stable

• v1alpha1 -> v1alpha2 -> v1alpha3 -> v1beta1 -> v1beta2 -> v1

오브젝트 정의

apiVersion:
kind:
metdata:
spec:

• kind: 오브젝트의 종류
• apiVersion: 지원하는 오브젝트의 버전
• metadata: 오브젝트의 메타데이터
  • 이름, 네임스페이스, 레이블, 어노테이션
• spec: 오브젝트에 대한 선언

kubectl explain pods
kubectl explain pods.metadata
kubectl explain pods.spec
kubectl explain pods.spec.containers
kubectl explain pods.spec.containers.images
kubectl explain pods.spec --recursive

오브젝트 관리

https://kubernetes.io/ko/docs/concepts/overview/working-with-objects/object-management/

• 명령형 커멘드: kubectl 명령으로만 구성
  • kubectl create
  • kubectl run
  • kubectl expose
• 명령형 오브젝트 구성: YAML 파일을 순서대로 하나씩 실행
  • kubectl create -f a.yaml
  • kubectl replace -f a.yaml
  • kubectl patch -f a.yaml
  • kubectl delete -f a.yaml
• 선언형 오브젝트 구성: YAML 파일의 모음을 한번에 실행
  • kubectl apply -f resources/