Kubernetes

Minikube

EBS 볼륨 사이즈 변경

curl -s https://raw.githubusercontent.com/youngwjung/aws-tools/main/resize.sh \
| bash /dev/stdin 30

Minikube 설치

{
    curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
    sudo install minikube-linux-amd64 /usr/local/bin/minikube
}

클러스터 생성
```
minikube start
```

실행중인 Pod 확인

minikube kubectl -- get pod --all-namespaces

데모 애플리케이션 배포

minikube kubectl -- run nginx --image=nginx

서비스 엔드포인트 생성

minikube kubectl -- expose pod nginx --port=80 --type=NodePort

서비스 엔드포인트 및 포트 확인
```
minikube service nginx
```
서비스 엔드포인트로 접속되는지 확인
```
curl $(minikube service nginx --url)
```
클러스터 삭제
```
minikube delete
```

쿠버네티스 클러스터 생성

실습 환경 생성

{
    cd ~/environment/container-labs
    git pull
    terraform init
    terraform apply --target=module.kubernetes --auto-approve
}

인스턴스 정보 확인

terraform show -json |\
jq -r '.values.root_module.child_modules | .[].resources | .[] | select(.address | contains("module.kubernetes.aws_instance")) | .name + ": " + .values.public_ip'

SSH 비밀번호 확인

terraform show -json |\
jq -r '.values.root_module.child_modules | .[].resources | .[] | select(.address == "module.kubernetes.random_password.this").values.result'

새로운 터미널을 열고 첫번째 컨트롤 플레인 노드로 사용할 인스턴스로 SSH 연결
```
ssh root@CP_IP_ADDRESS
```

시스템 구동에 필요한 라이브러리 설치

sudo apt update && sudo apt install -y \
curl apt-transport-https vim git wget gnupg2 net-tools \
software-properties-common lsb-release ca-certificates uidmap

컨테이너 런타임 구동에 필요한 overlay와 br_netfilter 커널 모듈 불러오기

{
    cat <<EOF | sudo tee /etc/modules-load.d/kubernetes.conf
overlay
br_netfilter
EOF

    sudo modprobe overlay
    sudo modprobe br_netfilter
}

컨테이너 런타임 구동에 필요한 커널 파라미터 설정

{
    cat <<EOF | sudo tee /etc/sysctl.d/kubernetes.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

    sudo sysctl --system
}

containerd 설치

{
    sudo mkdir -p /etc/apt/keyrings
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
    echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
    sudo apt update && apt install -y containerd.io
    sudo containerd config default | tee /etc/containerd/config.toml
    sudo sed -e 's/SystemdCgroup = false/SystemdCgroup = true/g' -i /etc/containerd/config.toml
    sudo systemctl restart containerd
}

쿠버네티스 설치 및 구동에 필요한 바이너리 설치

{
    curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
    echo "deb  http://apt.kubernetes.io/  kubernetes-xenial  main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
    sudo apt update && sudo apt install -y kubelet=1.28.1-00 kubeadm=1.28.1-00 kubectl=1.28.1-00
}

/etc/hosts 파일에 아래와 같은 라인 추가 - CP_IP_ADDRESS는 CP 노드 IP주소
```
CP_IP_ADDRESS k8scp
```
예를들어 CP의 IP주소가 123.45.67.89라면 아래처럼 입력
```
123.45.67.89 k8scp
```

클러스터 설정 파일 생성

cat << EOF | tee kubeadm-config.yaml
apiVersion: kubeadm.k8s.io/v1beta3
kind: ClusterConfiguration
kubernetesVersion: 1.28.1
controlPlaneEndpoint: "k8scp:6443"
networking:
  podSubnet: 192.168.0.0/16
EOF

컨트롤 플레인 노드 구성

kubeadm init --config=kubeadm-config.yaml --upload-certs | tee kubeadm-init.out

kubeconfig 파일 복사

{
    mkdir -p $HOME/.kube
    sudo cp /etc/kubernetes/admin.conf $HOME/.kube/config
}

kubeconfig 파일 확인
```
cat ~/.kube/config
```
실행중인 Pod 확인
```
kubectl get pod --all-namespaces
```

Pending 상태의 Pod의 상세내용 확인

kubectl describe pod \
$(kubectl get pod -A --field-selector=status.phase=Pending -o=jsonpath='{.items[0].metadata.name}') \
-n $(kubectl get pod -A --field-selector=status.phase=Pending -o=jsonpath='{.items[0].metadata.namespace}')

노드 목록 확인
```
kubectl get node
```
CP 노드 상태 확인
```
kubectl describe node cp
```

kubelet 로그 확인

sudo journalctl -u kubelet -n 10 --no-pager

CNI 플러그인 설치

kubectl apply -f \
https://raw.githubusercontent.com/youngwjung/lf-training/main/LFS458/v1.28.1/SOLUTIONS/s_03/cilium-cni.yaml

실행중인 Pod 확인
```
kubectl get pod -A
```
CP 노드 상태 확인
```
kubectl describe node cp
```

kubectl 명령어에 대한 bash completion 설정

{
    echo 'source <(kubectl completion bash)' >>~/.bashrc
    source <(kubectl completion bash)
}

새로운 터미널을 열고 워커 노드로 사용할 인스턴스로 SSH 연결
```
ssh root@WORKER_IP_ADDRESS
```

시스템 구동에 필요한 라이브러리 설치

sudo apt update && sudo apt install -y \
curl apt-transport-https vim git wget gnupg2 net-tools \
software-properties-common lsb-release ca-certificates uidmap

컨테이너 런타임 구동에 필요한 overlay와 br_netfilter 커널 모듈 불러오기

{
    cat <<EOF | sudo tee /etc/modules-load.d/kubernetes.conf
overlay
br_netfilter
EOF

    sudo modprobe overlay
    sudo modprobe br_netfilter
}

컨테이너 런타임 구동에 필요한 커널 파라미터 설정

{
    cat <<EOF | sudo tee /etc/sysctl.d/kubernetes.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

    sudo sysctl --system
}

containerd 설치

{
    sudo mkdir -p /etc/apt/keyrings
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
    echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
    sudo apt update && apt install -y containerd.io
    sudo containerd config default | tee /etc/containerd/config.toml
    sudo sed -e 's/SystemdCgroup = false/SystemdCgroup = true/g' -i /etc/containerd/config.toml
    sudo systemctl restart containerd
}

쿠버네티스 설치 및 구동에 필요한 바이너리 설치

{
    curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
    echo "deb  http://apt.kubernetes.io/  kubernetes-xenial  main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
    sudo apt update && sudo apt install -y kubelet=1.28.1-00 kubeadm=1.28.1-00 kubectl=1.28.1-00
}

/etc/hosts 파일에 아래와 같은 라인 추가 - CP_IP_ADDRESS는 CP 노드 IP주소
```
CP_IP_ADDRESS k8scp
```
컨트롤 플레인 노드에 연결된 터미널로 이동

Worker 노드 조인 명령어 생성

kubeadm token create --print-join-command --ttl 0

Worker 노드에 연결된 터미널로 이동해서 위의 명령어를 실행하고 나온 명령어를 실행
컨트롤 플레인 노드에 연결된 터미널로 이동
노드 상태 확인
```
kubectl get no
```

샘플 애플리케이션 배포

Deployment 생성

kubectl create deployment nginx --image=nginx

Deployment 상태 확인
```
kubectl get deploy
```
Pod가 생성되었는지 확인
```
kubectl get pod
```
생성된 NGINX Deployment 상태 상세 확인
```
kubectl describe deployment nginx 
```

클러스터에 발생한 이벤트 확인

kubectl get events  --sort-by='.metadata.creationTimestamp'

Deployment에 속하는 Pod 삭제
```
kubectl delete pod -l app=nginx
```
Pod가 존재하는지 확인
```
kubectl get pod
```
Service 생성
```
kubectl expose deploy nginx --port 80
```
NGINX 서비스 확인
```
kubectl get svc nginx
```
NGINX 서비스에 연결된 Endpoints 확인
```
kubectl get ep nginx
```
실행중인 Pod의 IP 주소 확인
```
kubectl get pod -l app=nginx -o wide
```
서비스 엔드포인트 및 포트 확인
```
kubectl get svc nginx
```

NGINX 서비스의 ClusterIP에 HTTP 요청

curl $(kubectl get svc nginx -o=jsonpath='{.spec.clusterIP}')

NGINX 서비스에 연결된 Endpoints 주소로 HTTP 요청

curl $(kubectl get ep nginx -o=jsonpath='{.subsets[0].addresses[0].ip}:{.subsets[0].ports[0].port}')

NGINX Deployment의 Replica 갯수를 3개로 변경
```
kubectl scale deployment nginx --replicas=3
```
Pod가 추가로 생성됐는지 확인
```
kubectl get pod -l app=nginx -o wide
```
NGINX 서비스에 연결된 Endpoints 확인
```
kubectl get ep nginx
```

NGNIX 서비스를 NodePort 타입으로 변경

kubectl patch svc nginx --type='json' -p '[{"op":"replace","path":"/spec/type","value":"NodePort"}]'

NGINX Service 엔드포인트 및 포트 확인
```
kubectl get svc nginx
```
웹브라우저에서 ANY_NODE_IP:SERVICE_NODE_PORT 로 접속되는지 확인 - 아래 명령어로 주소 확인 가능
```
echo "$(curl -s ifconfig.io):$(kubectl get svc nginx -o=jsonpath='{.spec.ports[0].nodePort}')"
```
NGINX Deployment의 Replica 갯수를 0개로 변경
```
kubectl scale deployment nginx --replicas=0
```
웹브라우저에서 ANY_NODE_IP:SERVICE_PORT 로 접속되는지 확인
NGINX Deployment의 Replica 갯수를 2개로 변경
```
kubectl scale deployment nginx --replicas=2
```
웹브라우저에서 ANY_NODE_IP:SERVICE_PORT 로 접속되는지 확인

리소스 삭제

{
    kubectl delete deployment nginx
    kubectl delete svc nginx
}

고가용성 쿠버네티스 클러스터 구성

HAProxy로 SSH 접속
```
ssh root@HAPROXY_IP_ADDRESS
```

HAProxy 설치

sudo apt update && sudo apt install -y haproxy

HAProxy 설정파일 /etc/haproxy/haproxy.cfg 에 아래의 라인들을 추가 - CP_IP_ADDRESS에 CP 노드의 IP 주소를 넣으세요.

frontend kubernetes-cp
   mode	tcp
   option tcplog
   bind *:6443
   default_backend kubernetes-cp-nodes

backend kubernetes-cp-nodes
   mode tcp
   balance roundrobin
   server cp1 CP_IP_ADDRESS:6443 check  

listen stats
     bind :9999
     mode http
     stats enable
     stats hide-version
     stats uri /stats

HAProxy 데몬을 재시작하고 상태 확인

{
    sudo systemctl restart haproxy
    sudo systemctl status haproxy --no-pager
}

CP 노드에 연결된 터미널로 이동
/etc/hosts 파일에서 k8scp에 지정된 IP주소를 HAProxy IP 주소로 변경
```
HAPROXY_IP_ADDRESS k8scp
```
Worker 노드에 연결된 터미널로 이동
/etc/hosts 파일에서 k8scp에 지정된 IP주소를 HAProxy IP 주소로 변경
```
HAPROXY_IP_ADDRESS k8scp
```
웹 브라우저를 열고 HAPROXY_IP_ADDRESS:9999/stats 주소로 접속
CP 노드에 연결된 터미널로 이동

kubectl 명령어로 API 호출

{
    kubectl get node
    kubectl get pod -A
}

HAProxy 통계 페이지를 리프레시해서 트래픽 정보가 업데이트 되는지 확인
SecondCP로 SSH 접속
```
ssh root@SECOND_CP_IP_ADDRESS
```

시스템 구동에 필요한 라이브러리 설치

sudo apt update && sudo apt install -y \
curl apt-transport-https vim git wget gnupg2 net-tools \
software-properties-common lsb-release ca-certificates uidmap

컨테이너 런타임 설치

{
    cat <<EOF | sudo tee /etc/modules-load.d/kubernetes.conf
overlay
br_netfilter
EOF

    sudp modprobe overlay
    sudo modprobe br_netfilter

    cat <<EOF | sudo tee /etc/sysctl.d/kubernetes.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

    sudo sysctl --system
    
    sudo mkdir -p /etc/apt/keyrings
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
    echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
    sudo apt update && apt install -y containerd.io
    sudo containerd config default | tee /etc/containerd/config.toml
    sudo sed -e 's/SystemdCgroup = false/SystemdCgroup = true/g' -i /etc/containerd/config.toml
    sudo systemctl restart containerd
}

쿠버네티스 설치

{
    curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
    echo "deb  http://apt.kubernetes.io/  kubernetes-xenial  main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
    sudo apt update && apt install -y kubelet=1.28.1-00 kubeadm=1.28.1-00 kubectl=1.28.1-00
}

/etc/hosts 파일에 아래와 같은 라인 추가
```
HAPROXY_IP_ADDRESS k8scp
```
ThirdCP로 SSH 접속
```
ssh root@THIRD_CP_IP_ADDRESS
```
14번부터 17번 단계를 실행
CP 노드에 연결된 터미널로 이동

컨트롤 플레인 조인 명령어 생성

echo "sudo kubeadm join k8scp:6443 --control-plane \
--token $(sudo kubeadm token create) \
--discovery-token-ca-cert-hash sha256:$(openssl x509 -pubkey \
-in /etc/kubernetes/pki/ca.crt | openssl rsa \
-pubin -outform der 2>/dev/null | openssl dgst \
-sha256 -hex | grep -oE '[A-z0-9]+$') \
--certificate-key $(sudo kubeadm init phase upload-certs --upload-certs| tail -1)"

위에서 생성한 명령어를 SecondCP 노드 및 ThirdCP 노드에 실행
HAProxy 노드에 연결된 터미널로 이동

HAProxy 설정파일 /etc/haproxy/haproxy.cfg 을 아래와 같이 수정

...
...
backend kubernetes-cp-nodes
   mode tcp
   balance roundrobin
   server cp1 CP_IP_ADDRESS:6443 check
   server cp2 SECOND_CP_IP_ADDRESS:6443 check
   server cp3 THIRD_CP_IP_ADDRESS:6443 check

HAProxy 데몬을 재시작하고 상태 확인

{
    sudo systemctl restart haproxy
    sudo systemctl status haproxy --no-pager
}

웹 브라우저를 열고 HAPROXY_IP_ADDRESS:9999/stats 주소로 접속해서 위에서 추가한 노드들의 연결 상태 확인
CP 노드에 연결된 터미널로 이동
Node 목록 확인
```
kubectl get node
```
kubectl 명령어로 몇가지 API 호출을 실행하고 HAProxy 통계사이트에서 로드가 분산되는지 확인
```
for i in {1..10}; do kubectl get pod; done
```

고가용성 테스트

실행중인 ETCD Pod 확인

kubectl get pod -n kube-system -l component=etcd

ETCD Pod 로그 확인

kubectl -n kube-system logs etcd-secondcp | grep leader

실행중인 ETCD Pod의 IP 주소 확인

kubectl get pod -n kube-system -l component=etcd -o wide

ETCD 클러스터의 멤버 목록 확인

kubectl -n kube-system exec -it etcd-cp -- \
etcdctl -w table \
--endpoints localhost:2379 \
--cacert /etc/kubernetes/pki/etcd/ca.crt \
--cert /etc/kubernetes/pki/etcd/server.crt \
--key /etc/kubernetes/pki/etcd/server.key \
member list

ETCD 클러스터 멤버 목록을 환경변수로 지정

{
    export ETCD_ENDPOINTS=$(kubectl -n kube-system exec -it etcd-cp -- \
    etcdctl -w json \
    --endpoints localhost:2379 \
    --cacert /etc/kubernetes/pki/etcd/ca.crt \
    --cert /etc/kubernetes/pki/etcd/server.crt \
    --key /etc/kubernetes/pki/etcd/server.key \
    member list \
    | jq -r '.members | map(.clientURLs[]) | join(",")')
    echo $ETCD_ENDPOINTS
}

ETCD 클러스터의 리더 확인

kubectl -n kube-system exec -it etcd-cp -- \
etcdctl -w table \
--endpoints $ETCD_ENDPOINTS \
--cacert /etc/kubernetes/pki/etcd/ca.crt \
--cert /etc/kubernetes/pki/etcd/server.crt \
--key /etc/kubernetes/pki/etcd/server.key \
endpoint status

ETCD 클러스터의 각 멤버별 상태 확인

kubectl -n kube-system exec -it etcd-cp -- \
etcdctl -w table \
--endpoints $ETCD_ENDPOINTS \
--cacert /etc/kubernetes/pki/etcd/ca.crt \
--cert /etc/kubernetes/pki/etcd/server.crt \
--key /etc/kubernetes/pki/etcd/server.key \
endpoint health

ETCD 클러스터의 리더 Pod가 배포된 노드에 가서 kubelet 및 컨테이너 런타임 정지- CP 노드의 ETCD가 가장 먼저 구성되었기 때문에 일반적으로 CP 노드에 배포된 ETCD가 리더

{
    sudo systemctl stop kubelet
    sudo crictl --runtime-endpoint=unix:///run/containerd/containerd.sock \
    stop $(sudo crictl --runtime-endpoint=unix:///run/containerd/containerd.sock ps -q)
    sudo systemctl stop containerd.service
}

ETCD Pod 로그 확인

kubectl -n kube-system logs etcd-secondcp | grep leader

웹 브라우저를 열고 HAPROXY_IP_ADDRESS:9999/stats 주소로 접속해서 위에서 노드들의 연결 상태 확인

ETCD 클러스터의 리더가 변경되었는지 확인

kubectl -n kube-system exec -it etcd-secondcp -- \
etcdctl -w table \
--endpoints $ETCD_ENDPOINTS \
--cacert /etc/kubernetes/pki/etcd/ca.crt \
--cert /etc/kubernetes/pki/etcd/server.crt \
--key /etc/kubernetes/pki/etcd/server.key \
endpoint status

ETCD 클러스터 각 멤버별 상태 확인

kubectl -n kube-system exec -it etcd-secondcp -- \
etcdctl -w table \
--endpoints $ETCD_ENDPOINTS \
--cacert /etc/kubernetes/pki/etcd/ca.crt \
--cert /etc/kubernetes/pki/etcd/server.crt \
--key /etc/kubernetes/pki/etcd/server.key \
endpoint health

Node 상태 확인
```
kubectl get node
```

CP 노드에서 kubelet 및 컨테이너 런타임을 재실행

{
    sudo systemctl start containerd.service
    sudo systemctl start kubelet
}

웹 브라우저를 열고 HAPROXY_IP_ADDRESS:9999/stats 주소로 접속해서 위에서 노드들의 연결 상태 확인
노드 상태 확인
```
kubectl get node
```
모든 Pod가 정상적으로 실행되고 있는지 확인
```
kubectl get pod -A -o wide
```

ETCD 클러스터의 리더가 다시 변경되었는지 확인

kubectl -n kube-system exec -it etcd-secondcp -- \
etcdctl -w table \
--endpoints $ETCD_ENDPOINTS \
--cacert /etc/kubernetes/pki/etcd/ca.crt \
--cert /etc/kubernetes/pki/etcd/server.crt \
--key /etc/kubernetes/pki/etcd/server.key \
endpoint status

ETCD 클러스터 각 멤버별 상태 확인

kubectl -n kube-system exec -it etcd-secondcp -- \
etcdctl -w table \
--endpoints $ETCD_ENDPOINTS \
--cacert /etc/kubernetes/pki/etcd/ca.crt \
--cert /etc/kubernetes/pki/etcd/server.crt \
--key /etc/kubernetes/pki/etcd/server.key \
endpoint health

Cloud9에 연결된 터미널로 이동해서 리소스 삭제

{
    cd ~/environment/container-labs
    terraform destroy --target=module.kubernetes --auto-approve
}

Amazon EKS

eksctl 설치

{
    cd ~/environment
    curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp
    sudo mv /tmp/eksctl /usr/local/bin
}

eksctl 버전 확인
```
eksctl version
```
현재 로그인된 IAM 자격증명 확인
```
aws sts get-caller-identity
```
IAM 자격증명 설정 - https://kubernetes.youngwjung.com/preparation/cloud9#cloud9

EKS 클러스터 생성

eksctl create cluster \
--name mycluster \
--nodes-min=2 \
--nodes-max=5 \
--region ap-northeast-2

kubectl 설치

{
    curl -LO "https://dl.k8s.io/release/v1.27.1/bin/linux/amd64/kubectl"
    sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
    echo 'source <(kubectl completion bash)' >>~/.bashrc
    source <(kubectl completion bash)
}

Node 목록 확인
```
kubectl get node
```
쿠버네티스 클러스터 버전 확인
```
kubectl version --short
```

Deployment 생성

kubectl create deployment nginx --image=nginx --replicas=3

생성된 Pod 확인
```
kubectl get po
```

Service 생성

kubectl expose deployment nginx --port 80 --type LoadBalancer

생성된 Service 확인
```
kubectl get svc nginx
```

생성된 ELB 주소 확인

kubectl get svc nginx \
-o=jsonpath='{.status.loadBalancer.ingress[0].hostname}{"\n"}'

웹브라우저에서 위에서 확인한 URL로 접속

리소스 삭제

{
    kubectl delete deploy nginx
    kubectl delete svc nginx
}

데모 애플리케이션 배포 - https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/#run-and-expose-php-apache-server

cat <<EOF | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: php-apache
spec:
  selector:
    matchLabels:
      app: php-apache
  replicas: 1
  template:
    metadata:
      labels:
        app: php-apache
    spec:
      containers:
      - name: php-apache
        image: k8s.gcr.io/hpa-example
        ports:
        - containerPort: 80
        resources:
          limits:
            cpu: 2
          requests:
            cpu: 1
---
apiVersion: v1
kind: Service
metadata:
  name: php-apache
  labels:
    app: php-apache
spec:
  ports:
  - port: 80
  selector:
    app: php-apache
EOF

Pod의 리소스 사용량 확인
```
kubectl top pod -l app=php-apache
```
Metrics Server 설치 - https://github.com/kubernetes-sigs/metrics-server#kubernetes-metrics-server
```
kubectl apply -f \
https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
```
Pod의 리소스 사용량 확인
```
kubectl top pod -l app=php-apache
```

데모 애플리케이션에 부하를 발생시키는 Pod 생성

kubectl create deploy load-generator \
--image=busybox:1.28 \
--replicas=10 \
-- /bin/sh -c "while sleep 0.01; do wget -q -O- http://php-apache; done"

Pod의 리소스 사용량 확인
```
kubectl top pod -l app=php-apache
```

HPA 생성

kubectl autoscale deployment php-apache --cpu-percent=50 --min=1 --max=5

위에서 생성한 HPA 상태 확인
```
kubectl get hpa php-apache
```
HPA 상태 모니터링
```
kubectl get hpa php-apache -w
```
Ctrl+C를 입력해서 HPA 모니터링을 중지하고 Pod가 생성되었는지 확인
```
kubectl get pod -l app=php-apache
```
Pod의 리소스 사용량 확인
```
kubectl top pod -l app=php-apache
```

Pending 상태의 Pod가 있다면 아래의 명령어를 통해서 그 이유를 확인

kubectl describe pod \
$(kubectl get pod -o=jsonpath='{.items[?(@.status.phase=="Pending")].metadata.name}')

Cluster Autoscaler 설치

{
    export CLUSTER_NAME=$(kubectl get node \
    -o=jsonpath='{.items[0].metadata.labels.alpha\.eksctl\.io\/cluster-name}')
    export ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
    export ASG_NAME=$(aws autoscaling describe-auto-scaling-groups --query \
    "AutoScalingGroups[? Tags[? (Key=='eks:cluster-name') && Value=='$CLUSTER_NAME']].AutoScalingGroupName" --output text)    
    
    eksctl utils associate-iam-oidc-provider --region=ap-northeast-2 \
    --cluster=$CLUSTER_NAME --approve
    
    eksctl create iamserviceaccount \
    --cluster=$CLUSTER_NAME \
    --namespace=kube-system \
    --name=cluster-autoscaler \
    --attach-policy-arn=arn:aws:iam::aws:policy/AmazonEC2FullAccess \
    --override-existing-serviceaccounts \
    --approve \
    --region ap-northeast-2
    
    kubectl apply -f \
    https://raw.githubusercontent.com/kubernetes/autoscaler/master/cluster-autoscaler/cloudprovider/aws/examples/cluster-autoscaler-autodiscover.yaml
    
    kubectl -n kube-system patch deployment cluster-autoscaler --type=json \
    -p='[{"op": "replace", "path": "/spec/template/spec/containers/0/command", "value": [
    "./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/'${CLUSTER_NAME}'",
    "--balance-similar-node-groups",
    "--skip-nodes-with-system-pods=false"
    ]}]'
}

Cluster Autoscaler 로그 확인

kubectl -n kube-system logs deploy/cluster-autoscaler

Pending 상태였던 Pod가 생성 되었는지 확인
```
kubectl get pod -l app=php-apache
```
Node 갯수 확인
```
kubectl get node
```
Pod의 리소스 사용량 확인
```
kubectl top pod -l app=php-apache
```
데모 애플리케이션에 부하를 발생시키는 Pod 삭제
```
kubectl delete deploy load-generator
```
Pod의 리소스 사용량 확인
```
kubectl top pod -l app=php-apache
```
HPA 상태 확인
```
kubectl get hpa php-apache
```
HPA 상세 내용 확인
```
kubectl describe hpa php-apache
```
데모 애플리케이션의 복제본 갯수는 1개로 강제 지정
```
kubectl scale deployment php-apache --replicas=1
```
Pod가 삭제 되었는지 확인
```
kubectl get pod -l app=php-apache
```
데모 애플리케이션 삭제
```
kubectl delete deploy php-apache
```
Pod가 삭제 되었는지 확인
```
kubectl get pod -l app=php-apache
```
Node가 삭제 되는지 확인
```
kubectl get node
```

Cluster Autoscaler 로그 확인

kubectl -n kube-system logs deploy/cluster-autoscaler

EKS 클러스터 삭제

eksctl delete cluster --name mycluster --region ap-northeast-2

PreviousSwarm Mode

Last updated 2 years ago

hashtagMinikube

hashtag쿠버네티스 클러스터 생성

hashtag샘플 애플리케이션 배포

hashtag고가용성 쿠버네티스 클러스터 구성

hashtag고가용성 테스트

hashtagAmazon EKS

Minikube

쿠버네티스 클러스터 생성

샘플 애플리케이션 배포

고가용성 쿠버네티스 클러스터 구성

고가용성 테스트

Amazon EKS