우분투 환경에서 쿠버네티스 설치하기 총정리 (24년 8월)

비교적 최신 버전 우분투에서 최신 버전 쿠버네티스 설치를 진행하였습니다.

Aug 19, 2024

Contents

설치 환경 1. 기본 우분투 환경 설정 1-1. 호스트 네임 변경 1-2. NTP 설정 1-3. 방화벽 설정 1-4. 도커 설치 2. 쿠버네티스 설치 사전준비 3. 쿠버네티스 설치(kubelet, kubeadm, kubectl 설치)4. Control-plane 구성(Only master node)5. Worker node 구성 6. Master에서 노드 확인 트러블 슈팅 사고 과정

본 설치가이드는 우분투 환경에서 쿠버네티스를 설치하는 과정이며 24년 8월 기준으로 정상 설치를 확인하였습니다.

설치 환경

CPU 2core 이상

메모리 2GB 이상

3대의 host 필요 (master node 1 EA, worker node 2 EA)

우분투 22.04 LTS OS가 설치된 host 3대

외부 인터넷이 되는 환경

1. 기본 우분투 환경 설정

1-1. 호스트 네임 변경

각 서버마다 hostname을 변경해줍니다.

이는 추후 kube-api 가 hostname 기반으로 통신을 하는데 필요합니다.

sudo hostnamectl set-hostname k8s-masterjw

sudo hostnamectl set-hostname k8s-worker1

sudo hostnamectl set-hostname k8s-worker2

1-2. NTP 설정

필수 환경은 아님

NTP 설치

sudo apt-get install -y ntp

sudo vi /etc/ntp.conf 파일 수정


# 아래 4개 주석처리 
#pool 0.ubuntu.pool.ntp.org iburst
#pool 1.ubuntu.pool.ntp.org iburst
#pool 2.ubuntu.pool.ntp.org iburst
#pool 3.ubuntu.pool.ntp.org iburst
# 아래 구문 추가 (iburst 옵션은 시스템의 시간의 차이와 상관없이 바로 동기화됨)
server 203.248.240.140 iburst

ntp 서비스 실행

sudo systemctl start ntp

sudo systemctl status ntp

동기화 상태 확인

ntpq -p

타임 존 변경 (서울시간)

sudo timedatectl set-timezone Asia/Seoul

시간 확인

date

1-3. 방화벽 설정

특정 포트로 외부에서 접속할 수 있도록 열기

iptables -I INPUT 1 -p tcp --dport 6443 -j ACCEPT

💡

외부에서 들어오는(INBOUND) TCP포트 6443의 연결을 받아들인다는 규칙을 1번 방화벽 규칙으로 추가한다는 의미이다.

1-4. 도커 설치

쿠버네티스는 컨테이너화된 애플리케이션을 관리하기 위한 오케스트레이션 도구이다. 이때 컨테이너를 생성하고 실행하는 역할을 하는 것이 컨테이너 런타임이다. 도커는 이러한 컨테이너 런타임 중 하나로, 쿠버네티스에서 컨테이너를 실행하고 관리하는 데 사용된다.

1-4-1. 저장소 설정

apt 업데이트


sudo apt-get update

sudo apt-get install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

도커 공식 GPG key 추가


curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

도커 Stable repository 설정


echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

💡

각 부분에 대한 설명 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg 부분은 도커 패키지를 설치할 때 사용할 GPG 키 파일의 위치를 지정하는 것 [arch=$(dpkg --print-architecture)] 부분은 사용 중인 시스템의 CPU 아키텍처를 자동으로 감지하여, 해당 아키텍처에 맞는 패키지를 다운로드할 수 있도록 설정 $(lsb_release -cs)는 현재 시스템의 우분투 배포판 코드네임(예: focal, bionic 등)을 자동으로 삽입하여, 해당 버전에 맞는 패키지를 다운로드할 수 있도록 설정 "deb https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" 부분은 도커 패키지가 제공되는 공식 저장소를 추가하는 것 apt가 패키지를 다운로드할 때 참조하는 위치 이 과정은 도커 패키지를 우분투 패키지 관리 시스템에서 사용할 수 있도록 하기 위해 필요함. 이후 apt-get update 명령을 실행하면 이 저장소에서 패키지 목록을 업데이트하게 됨 sudo tee /etc/apt/sources.list.d/docker.list > /dev/null 부분은 위에서 정의한 내용을 /etc/apt/sources.list.d/docker.list 파일에 저장하는 과정 > /dev/null은 명령 실행 결과를 화면에 출력하지 않고 무시하도록 함

⚠️

초기 시간설정 오류로 gpg 키가 업데이트가 제대로 되지 않는 증상 확인, 시간설정을 정상으로 했다면 해당 오류는 미발생할것으로 추정 (2024.11.25)

경로 수정/etc/apt/sources.list.d/kubernetes.list 파일에서 signed-by 옵션의 경로를 올바른 키 경로로 수정합니다.

수정 명령:


bash
코드 복사
sudo nano /etc/apt/sources.list.d/kubernetes.list

아래와 같이 변경:


plaintext
코드 복사
deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.30/deb/ /

저장 후 종료 (Ctrl+O, Enter, Ctrl+X).

APT 캐시 초기화 및 업데이트 캐시를 초기화하고 패키지 목록을 다시 업데이트합니다:


bash
코드 복사
sudo apt-get clean
sudo rm -rf /var/lib/apt/lists/*
sudo apt-get update

1-4-2. 도커 엔진 설치

최신버전 Docker Engine 및 containerd 설치


sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

version 확인


sudo docker version

Docker 서비스 등록 실행


sudo systemctl enable docker
sudo systemctl start docker

2. 쿠버네티스 설치 사전준비

메모리 스왑 비활성화


sudo swapoff -a && sudo sed -i '/swap/s/^/#/' /etc/fstab

노드간 통신을 위한 iptables에 브릿지 관련 설정 추가


cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
br_netfilter
EOF
 
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF

$ sudo sysctl --system

💡

과정에 대한 설명 net.bridge.bridge-nf-call-ip6tables와 net.bridge.bridge-nf-call-iptables: 이 설정들은 브릿지 네트워크 인터페이스에서 전달되는 IPv4와 IPv6 트래픽이 각각 iptables와 ip6tables에서 필터링될 수 있도록 활성화 GPT 설명 쿠버네티스는 네트워크 트래픽을 관리하기 위해 iptables 규칙을 사용합니다. 예를 들어, 서비스 간의 트래픽을 라우팅하거나 네트워크 정책을 적용할 때 iptables를 사용합니다. 이 설정들이 활성화되지 않으면 브릿지 인터페이스를 통한 트래픽이 iptables 필터링 규칙을 거치지 않고 그대로 통과해버릴 수 있습니다. 이는 쿠버네티스 네트워킹과 보안 정책이 제대로 작동하지 않게 만들 수 있습니다.

방화벽 비활성화


sudo ufw disable

3. 쿠버네티스 설치(kubelet, kubeadm, kubectl 설치)

3대의 호스트 모두에서 진행합니다. 구글 gpg 저장소가 만료되었습니다. 쿠버네티스 공식 홈페이지를 참고하여 새로운 자체 저장소로 세팅합니다. 아래 내용은 24년 8월 12일 정상동작함을 확인하였습니다. 반드시 쿠버네티스 홈페이지에서 영문버전의 최신 문서를 참고하여 진행해주세요 (쿠버네티스 공식 홈페이지, gpg 저장소 변경에 따른 관련 게시물)

kube 관련 gpg 키 등록 및 설치


$ sudo apt-get update

$ sudo apt-get install -y apt-transport-https ca-certificates curl gpg

$ mkdir /etc/apt/keyrings

$ curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.30/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

$ echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.30/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list


$ sudo apt-get update

$ sudo apt-get install -y kubelet kubeadm kubectl

$ sudo apt-mark hold kubelet kubeadm kubectl

$ sudo systemctl enable --now kubelet

systemd와 cgroup 설정 맞추기

쿠버네티스 설치 중에 다음과 같은 Docker 데몬 설정을 하는 이유는 쿠버네티스와 Docker가 원활하게 연동되고, 시스템의 리소스 관리 및 성능이 최적화될 수 있도록 환경을 구성하기 위함이다.


sudo mkdir /etc/docker
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

💡

각 과정에 대한 설명 (GPT) Docker와 쿠버네티스는 컨테이너의 리소스(CPU, 메모리 등)를 관리하기 위해 cgroup(Control Group)을 사용. cgroupdriver는 이 cgroup을 어떻게 관리할지를 결정하는 옵션 쿠버네티스는 systemd를 기본 cgroup 드라이버로 사용합니다. systemd는 현대 리눅스 시스템에서 표준 서비스 관리자로 사용되며, 시스템 리소스 관리와 관련하여 강력한 기능을 제공합니다. Docker도 systemd를 cgroup 드라이버로 사용하도록 설정하면, Docker와 쿠버네티스가 동일한 리소스 관리 방식으로 동작하게 되어, 일관된 리소스 관리 및 트러블슈팅이 가능해집니다. cgroup 드라이버가 일치하지 않으면, 쿠버네티스 클러스터에서 노드가 제대로 작동하지 않을 수 있으며, 리소스 관리의 비일관성으로 인해 예기치 않은 문제가 발생할 수 있습니다.

log-driver 이 설정은 Docker 컨테이너의 로그를 어떻게 관리할지 결정합니다.

json-file 로그 드라이버: Docker는 컨테이너의 로그를 여러 가지 방식으로 관리할 수 있는데, 그 중 하나가 json-file입니다. (max-size): 각 컨테이너의 로그 파일 크기를 100MB로 제한하여, 로그 파일이 무한히 커지는 것을 방지합니다 storage-driver 이 설정은 Docker가 컨테이너의 파일 시스템을 어떻게 관리할지를 결정합니다. overlay2는 현대 리눅스 커널에서 사용되는 가장 효율적인 스토리지 드라이버 중 하나로, 파일 시스템 계층을 효율적으로 관리합니다. 이는 Docker 컨테이너의 성능과 디스크 사용 효율성을 크게 개선할 수 있습니다.

쿠버네티스 서비스 등록 및 재시작 수행


sudo systemctl daemon-reload
sudo systemctl restart kubelet

4. Control-plane 구성(Only master node)

kubeadm을 통한 네트워크 설정 잡기


kubeadm init

##예시 (해당 예시는 특정 네트워크 설정을 걸고 init 진행)
root@k8s-masterjw:~# sudo kubeadm init --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address=192.168.1.130
[init] Using Kubernetes version: v1.30.3
[preflight] Running pre-flight checks
[preflight] Pulling images required for setting up a Kubernetes cluster
[preflight] This might take a minute or two, depending on the speed of your internet connection
[preflight] You can also perform this action in beforehand using 'kubeadm config images pull'
W0806 14:59:33.701897    1490 checks.go:844] detected that the sandbox image "registry.k8s.io/pause:3.8" of the container runtime is inconsistent with that used by kubeadm.It is recommended to use "registry.k8s.io/pause:3.9" as the CRI sandbox image.
[certs] Using certificateDir folder "/etc/kubernetes/pki"
[certs] Generating "ca" certificate and key
[certs] Generating "apiserver" certificate and key
[certs] apiserver serving cert is signed for DNS names [k8s-masterjw kubernetes kubernetes.default kubernetes.default.svc kubernetes.default.svc.cluster.local] and IPs [10.96.0.1 192.168.1.130]
[certs] Generating "apiserver-kubelet-client" certificate and key
[certs] Generating "front-proxy-ca" certificate and key
[certs] Generating "front-proxy-client" certificate and key
[certs] Generating "etcd/ca" certificate and key
[certs] Generating "etcd/server" certificate and key
[certs] etcd/server serving cert is signed for DNS names [k8s-masterjw localhost] and IPs [192.168.1.130 127.0.0.1 ::1]
[certs] Generating "etcd/peer" certificate and key
[certs] etcd/peer serving cert is signed for DNS names [k8s-masterjw localhost] and IPs [192.168.1.130 127.0.0.1 ::1]
[certs] Generating "etcd/healthcheck-client" certificate and key
[certs] Generating "apiserver-etcd-client" certificate and key
[certs] Generating "sa" key and public key
[kubeconfig] Using kubeconfig folder "/etc/kubernetes"
[kubeconfig] Writing "admin.conf" kubeconfig file
[kubeconfig] Writing "super-admin.conf" kubeconfig file
[kubeconfig] Writing "kubelet.conf" kubeconfig file
[kubeconfig] Writing "controller-manager.conf" kubeconfig file
[kubeconfig] Writing "scheduler.conf" kubeconfig file
[etcd] Creating static Pod manifest for local etcd in "/etc/kubernetes/manifests"
[control-plane] Using manifest folder "/etc/kubernetes/manifests"
[control-plane] Creating static Pod manifest for "kube-apiserver"
[control-plane] Creating static Pod manifest for "kube-controller-manager"
[control-plane] Creating static Pod manifest for "kube-scheduler"
[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Starting the kubelet
[wait-control-plane] Waiting for the kubelet to boot up the control plane as static Pods from directory "/etc/kubernetes/manifests"
[kubelet-check] Waiting for a healthy kubelet. This can take up to 4m0s
[kubelet-check] The kubelet is healthy after 501.198004ms
[api-check] Waiting for a healthy API server. This can take up to 4m0s
[api-check] The API server is healthy after 3.001049923s
[upload-config] Storing the configuration used in ConfigMap "kubeadm-config" in the "kube-system" Namespace
[kubelet] Creating a ConfigMap "kubelet-config" in namespace kube-system with the configuration for the kubelets in the cluster
[upload-certs] Skipping phase. Please see --upload-certs
[mark-control-plane] Marking the node k8s-masterjw as control-plane by adding the labels: [node-role.kubernetes.io/control-plane node.kubernetes.io/exclude-from-external-load-balancers]
[mark-control-plane] Marking the node k8s-masterjw as control-plane by adding the taints [node-role.kubernetes.io/control-plane:NoSchedule]
[bootstrap-token] Using token: equz26.fgcu09jf44ild3vz
[bootstrap-token] Configuring bootstrap tokens, cluster-info ConfigMap, RBAC Roles
[bootstrap-token] Configured RBAC rules to allow Node Bootstrap tokens to get nodes
[bootstrap-token] Configured RBAC rules to allow Node Bootstrap tokens to post CSRs in order for nodes to get long term certificate credentials
[bootstrap-token] Configured RBAC rules to allow the csrapprover controller automatically approve CSRs from a Node Bootstrap Token
[bootstrap-token] Configured RBAC rules to allow certificate rotation for all node client certificates in the cluster
[bootstrap-token] Creating the "cluster-info" ConfigMap in the "kube-public" namespace
[kubelet-finalize] Updating "/etc/kubernetes/kubelet.conf" to point to a rotatable kubelet client certificate and key
[addons] Applied essential addon: CoreDNS
[addons] Applied essential addon: kube-proxy

Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

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

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 192.168.1.130:6443 --token equz26.fgcu09jf44ild3vz \
        --discovery-token-ca-cert-hash sha256:b205ddcc59d0ddbf578a6c28eab094ef86f0d5ff7ee99dcdaa3231b7e4681447

아래와 같은 토큰 발행 시 복사해놓기


kubeadm join 192.168.1.130:6443 --token equz26.fgcu09jf44ild3vz \
        --discovery-token-ca-cert-hash sha256:b205ddcc59d0ddbf578a6c28eab094ef86f0d5ff7ee99dcdaa3231b7e4681447

모든 사용자 kube 명령어 사용


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

⚠️

kube init 시 에러발생할 경우 container is not runtime runnig unknown service runtime.v1.RuntimeService error 다음과 같은 에러가 발생한다면


sudo rm /etc/containerd/config.toml
sudo systemctl restart containerd
sudo kubeadm init

6443 포트 관련 에러가 발생한다면


containerd config default | tee /etc/containerd/config.toml
sed -i 's/SystemdCgroup = false/SystemdCgroup = true/g' /etc/containerd/config.toml
service containerd restart
service kubelet restart

Pod network 애드온 설치(only master)


kubectl apply -f https://github.com/weaveworks/weave/releases/download/v2.8.1/weave-daemonset-k8s.yaml

💡

해당 명령어는 쿠버네티스 클러스터에 Weave Net이라는 네트워크 플러그인을 설치하는 과정이다. 쿠버네티스는 클러스터 내에서 각 노드와 파드들이 서로 통신할 수 있도록 별도의 플러그인을 설치해야 한다. 이를 CNI라고 하는데 Weave Net 말고도 Flannel, Calico 등이 있다.

5. Worker node 구성

여기에서 작성된 토큰을 워커노드에 그대로 붙여넣는다. (각 환경마다 아래 값은 상이함)


kubeadm join 192.168.1.130:6443 --token equz26.fgcu09jf44ild3vz \
        --discovery-token-ca-cert-hash sha256:b205ddcc59d0ddbf578a6c28eab094ef86f0d5ff7ee99dcdaa3231b7e4681447

⚠️

워커노드 join 시 error 발생할 경우 [ERROR CRI]: container runtime is not running 에러 발생할 경우


/etc/containerd/config.toml 파일에서
disabled_plugins 항목에서 CRI 제거한 뒤 혹은 주석처리 한 뒤

sudo systemctl restart containerd

6. Master에서 노드 확인

노드 연결 확인


kubectl get nodes -o wide

# 실제 콘솔
root@k8s-masterjw:~# kubectl get nodes
NAME           STATUS   ROLES           AGE   VERSION
k8s-masterjw   Ready    control-plane   11d   v1.30.3
k8s-node1jw    Ready    <none>          11d   v1.30.3
k8s-node2jw    Ready    <none>          11d   v1.30.3

kubectl 명령어를 tab하여 자동완성 설정(무조건 필수. 정말 편함)


$ source <(kubectl completion bash)
$ echo "source <(kubectl completion bash)" >> ~/.bashrc

k 만 입력해도 kubectl 로 인식하게 하기


$ vi ~/.bashrc

# .bashrc 해당 파일의 아래 구문 입력
alias k='kubectl'

#변경사항 적용
source ~/.bashrc

트러블 슈팅

클러스터 구성 후 kube-proxy pod 및 CNI 관련 pod가 정상 실행되지 않는 증상 확인

Pod sandbox changed, it will be killed and re-created. 이라는 로그를 확인하였다.

사고 과정

장애 파드가 네트워크 설정 이다 > CRI 관련 설정 및 systemd 설정 문제가 아닐까?

kubelet 로그 확인 방법

journalctl -u kubelet -f kubelet 로그

클러스터 구성 후 proxy가 죽는 현상이 있어 검색

아래 글이 나와 상황이 완전 동일한데 거기서

kube-proxy - Pod sandbox changed, it will be killed and re-created

‘

이 URL을 확인해보라고 하였다.

GitHubcontainerd/docs/cri/config.md at main · containerd/containerd

containerd/docs/cri/config.md at main · containerd/containerd

An open and reliable container runtime. Contribute to containerd/containerd development by creating an account on GitHub.

💡

위 게시글 내용은 쿠버네티스 공식 홈페이지의 CNI 설정에서 확인 가능하다

Container Runtimes

Note: Dockershim has been removed from the Kubernetes project as of release 1.24. Read the Dockershim Removal FAQ for further details. You need to install a container runtime into each node in the cluster so that Pods can run there. This page outlines what is involved and describes related tasks for setting up nodes. Kubernetes 1.30 requires that you use a runtime that conforms with the Container Runtime Interface (CRI).

워커노드의 /etc/containerd/config.toml 파일의 구성이 제대로 되어있지 않았다.

어떤 이유에서인지는 모르겠지만 마스터 노드의 설정을 그대로 옮겨와서 증상 해결

워커노드의 config.toml에서 아래 옵션을 포함해서 여러 설정파일을 넣어주었다.


  [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
    SystemdCgroup = true

아래의 설정값을 워커노드의 config.toml 에 옮긴 후 해결


disabled_plugins = []
imports = []
oom_score = 0
plugin_dir = ""
required_plugins = []
root = "/var/lib/containerd"
state = "/run/containerd"
temp = ""
version = 2

[cgroup]
  path = ""

[debug]
  address = ""
  format = ""
  gid = 0
  level = ""
  uid = 0

[grpc]
  address = "/run/containerd/containerd.sock"
  gid = 0
  max_recv_message_size = 16777216
  max_send_message_size = 16777216
  tcp_address = ""
  tcp_tls_ca = ""
  tcp_tls_cert = ""
  tcp_tls_key = ""
  uid = 0

[metrics]
  address = ""
  grpc_histogram = false

[plugins]

  [plugins."io.containerd.gc.v1.scheduler"]
    deletion_threshold = 0
    mutation_threshold = 100
    pause_threshold = 0.02
    schedule_delay = "0s"
    startup_delay = "100ms"

  [plugins."io.containerd.grpc.v1.cri"]
    cdi_spec_dirs = ["/etc/cdi", "/var/run/cdi"]
    device_ownership_from_security_context = false
    disable_apparmor = false
    disable_cgroup = false
    disable_hugetlb_controller = true
    disable_proc_mount = false
    disable_tcp_service = true
    drain_exec_sync_io_timeout = "0s"
    enable_cdi = false
    enable_selinux = false
    enable_tls_streaming = false
    enable_unprivileged_icmp = false
    enable_unprivileged_ports = false
    ignore_deprecation_warnings = []
    ignore_image_defined_volumes = false
    image_pull_progress_timeout = "5m0s"
    image_pull_with_sync_fs = false
    max_concurrent_downloads = 3
    max_container_log_line_size = 16384
    netns_mounts_under_state_dir = false
    restrict_oom_score_adj = false
    sandbox_image = "registry.k8s.io/pause:3.8"
    selinux_category_range = 1024
    stats_collect_period = 10
    stream_idle_timeout = "4h0m0s"
    stream_server_address = "127.0.0.1"
    stream_server_port = "0"
    systemd_cgroup = false
    tolerate_missing_hugetlb_controller = true
    unset_seccomp_profile = ""

    [plugins."io.containerd.grpc.v1.cri".cni]
      bin_dir = "/opt/cni/bin"
      conf_dir = "/etc/cni/net.d"
      conf_template = ""
      ip_pref = ""
      max_conf_num = 1
      setup_serially = false

    [plugins."io.containerd.grpc.v1.cri".containerd]
      default_runtime_name = "runc"
      disable_snapshot_annotations = true
      discard_unpacked_layers = false
      ignore_blockio_not_enabled_errors = false
      ignore_rdt_not_enabled_errors = false
      no_pivot = false
      snapshotter = "overlayfs"

      [plugins."io.containerd.grpc.v1.cri".containerd.default_runtime]
        base_runtime_spec = ""
        cni_conf_dir = ""
        cni_max_conf_num = 0
        container_annotations = []
        pod_annotations = []
        privileged_without_host_devices = false
        privileged_without_host_devices_all_devices_allowed = false
        runtime_engine = ""
        runtime_path = ""
        runtime_root = ""
        runtime_type = ""
        sandbox_mode = ""
        snapshotter = ""

        [plugins."io.containerd.grpc.v1.cri".containerd.default_runtime.options]

      [plugins."io.containerd.grpc.v1.cri".containerd.runtimes]

        [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc]
          base_runtime_spec = ""
          cni_conf_dir = ""
          cni_max_conf_num = 0
          container_annotations = []
          pod_annotations = []
          privileged_without_host_devices = false
          privileged_without_host_devices_all_devices_allowed = false
          runtime_engine = ""
          runtime_path = ""
          runtime_root = ""
          runtime_type = "io.containerd.runc.v2"
          sandbox_mode = "podsandbox"
          snapshotter = ""

          [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
            BinaryName = ""
            CriuImagePath = ""
            CriuPath = ""
            CriuWorkPath = ""
            IoGid = 0
            IoUid = 0
            NoNewKeyring = false
            NoPivotRoot = false
            Root = ""
            ShimCgroup = ""
            SystemdCgroup = true

      [plugins."io.containerd.grpc.v1.cri".containerd.untrusted_workload_runtime]
        base_runtime_spec = ""
        cni_conf_dir = ""
        cni_max_conf_num = 0
        container_annotations = []
        pod_annotations = []
        privileged_without_host_devices = false
        privileged_without_host_devices_all_devices_allowed = false
        runtime_engine = ""
        runtime_path = ""
        runtime_root = ""
        runtime_type = ""
        sandbox_mode = ""
        snapshotter = ""

        [plugins."io.containerd.grpc.v1.cri".containerd.untrusted_workload_runtime.options]

    [plugins."io.containerd.grpc.v1.cri".image_decryption]
      key_model = "node"

    [plugins."io.containerd.grpc.v1.cri".registry]
      config_path = ""

      [plugins."io.containerd.grpc.v1.cri".registry.auths]

      [plugins."io.containerd.grpc.v1.cri".registry.configs]

      [plugins."io.containerd.grpc.v1.cri".registry.headers]

      [plugins."io.containerd.grpc.v1.cri".registry.mirrors]

    [plugins."io.containerd.grpc.v1.cri".x509_key_pair_streaming]
      tls_cert_file = ""
      tls_key_file = ""

  [plugins."io.containerd.internal.v1.opt"]
    path = "/opt/containerd"

  [plugins."io.containerd.internal.v1.restart"]
    interval = "10s"

  [plugins."io.containerd.internal.v1.tracing"]

  [plugins."io.containerd.metadata.v1.bolt"]
    content_sharing_policy = "shared"

  [plugins."io.containerd.monitor.v1.cgroups"]
    no_prometheus = false

  [plugins."io.containerd.nri.v1.nri"]
    disable = true
    disable_connections = false
    plugin_config_path = "/etc/nri/conf.d"
    plugin_path = "/opt/nri/plugins"
    plugin_registration_timeout = "5s"
    plugin_request_timeout = "2s"
    socket_path = "/var/run/nri/nri.sock"

  [plugins."io.containerd.runtime.v1.linux"]
    no_shim = false
    runtime = "runc"
    runtime_root = ""
    shim = "containerd-shim"
    shim_debug = false

  [plugins."io.containerd.runtime.v2.task"]
    platforms = ["linux/amd64"]
    sched_core = false

  [plugins."io.containerd.service.v1.diff-service"]
    default = ["walking"]

  [plugins."io.containerd.service.v1.tasks-service"]
    blockio_config_file = ""
    rdt_config_file = ""

  [plugins."io.containerd.snapshotter.v1.aufs"]
    root_path = ""

  [plugins."io.containerd.snapshotter.v1.blockfile"]
    fs_type = ""
    mount_options = []
    root_path = ""
    scratch_file = ""

  [plugins."io.containerd.snapshotter.v1.btrfs"]
    root_path = ""

  [plugins."io.containerd.snapshotter.v1.devmapper"]
    async_remove = false
    base_image_size = ""
    discard_blocks = false
    fs_options = ""
    fs_type = ""
    pool_name = ""
    root_path = ""

  [plugins."io.containerd.snapshotter.v1.native"]
    root_path = ""

  [plugins."io.containerd.snapshotter.v1.overlayfs"]
    mount_options = []
    root_path = ""
    sync_remove = false
    upperdir_label = false

  [plugins."io.containerd.snapshotter.v1.zfs"]
    root_path = ""

  [plugins."io.containerd.tracing.processor.v1.otlp"]

  [plugins."io.containerd.transfer.v1.local"]
    config_path = ""
    max_concurrent_downloads = 3
    max_concurrent_uploaded_layers = 3

    [[plugins."io.containerd.transfer.v1.local".unpack_config]]
      differ = ""
      platform = "linux/amd64"
      snapshotter = "overlayfs"

[proxy_plugins]

[stream_processors]

  [stream_processors."io.containerd.ocicrypt.decoder.v1.tar"]
    accepts = ["application/vnd.oci.image.layer.v1.tar+encrypted"]
    args = ["--decryption-keys-path", "/etc/containerd/ocicrypt/keys"]
    env = ["OCICRYPT_KEYPROVIDER_CONFIG=/etc/containerd/ocicrypt/ocicrypt_keyprovider.conf"]
    path = "ctd-decoder"
    returns = "application/vnd.oci.image.layer.v1.tar"

  [stream_processors."io.containerd.ocicrypt.decoder.v1.tar.gzip"]
    accepts = ["application/vnd.oci.image.layer.v1.tar+gzip+encrypted"]
    args = ["--decryption-keys-path", "/etc/containerd/ocicrypt/keys"]
    env = ["OCICRYPT_KEYPROVIDER_CONFIG=/etc/containerd/ocicrypt/ocicrypt_keyprovider.conf"]
    path = "ctd-decoder"
    returns = "application/vnd.oci.image.layer.v1.tar+gzip"

[timeouts]
  "io.containerd.timeout.bolt.open" = "0s"
  "io.containerd.timeout.metrics.shimstats" = "2s"
  "io.containerd.timeout.shim.cleanup" = "5s"
  "io.containerd.timeout.shim.load" = "5s"
  "io.containerd.timeout.shim.shutdown" = "3s"
  "io.containerd.timeout.task.state" = "2s"

[ttrpc]
  address = ""
  gid = 0
  uid = 0

2년전에 쿠버네티스 구성할때랑 조금 과정이 달라졌습니다.

쿠버네티스를 구축할때 본 게시글이 도움이 되었으면 좋겠습니다.

감사합니다.