Kubernetes 아키텍처 및 워크플로우 심층 분석

1. Kubernetes 아키텍처 개요
2. 컨트롤 플레인 컴포넌트 상세 분석
3. 워커 노드 컴포넌트 상세 분석
4. Pod 생성 워크플로우 심층 분석
5. Kubernetes 객체 관계
6. 선언적 상태 관리 워크플로우
7. Ingress 워크플로우
8. 운영 고려사항

Kubernetes 아키텍처 개요

Kubernetes(쿠버네티스)는 컨테이너화된 애플리케이션의 배포, 스케일링, 관리를 자동화하는 오픈소스 플랫폼입니다. 전체 아키텍처는 크게 컨트롤 플레인과 워커 노드로 구성됩니다.

GitHub 리포지토리: https://github.com/kubernetes/kubernetes

컨트롤 플레인은 클러스터의 '두뇌' 역할을 하며, 워커 노드는 실제 애플리케이션 컨테이너가 실행되는 곳입니다. 이 두 요소는 함께 작동하여 컨테이너화된 애플리케이션의 효율적인 배포와 관리를 가능하게 합니다.

컨트롤 플레인 컴포넌트 상세 분석

컨트롤 플레인 컴포넌트는 클러스터의 전체 상태를 관리하고 중요한 결정을 내리는 역할을 합니다.

1. kube-apiserver

소스 코드 위치: kubernetes/cmd/kube-apiserver/
핵심 파일: kubernetes/cmd/kube-apiserver/apiserver.go

kube-apiserver는 Kubernetes API를 노출시키는 프론트엔드입니다. 모든 관리 작업의 중심점이며, RESTful API를 통해 클러스터 상태를 쿼리하고 수정할 수 있게 합니다.

주요 기능:

• 인증 및 인가 처리
• API 요청 검증
• RESTful API 엔드포인트 제공
• etcd와의 통신

핵심 코드 구조:

// apiserver.go에서 API 서버 실행 함수
func Run(completeOptions completedServerRunOptions, stopCh <-chan struct{}) error {
    // 서버 구성
    server, err := CreateServerChain(completeOptions, stopCh)
    if err != nil {
        return err
    }
    
    // 서버 준비 및 실행
    prepared, err := server.PrepareRun()
    if err != nil {
        return err
    }
    
    return prepared.Run(stopCh)
}

2. etcd

소스 코드 위치: 외부 프로젝트 (https://github.com/etcd-io/etcd)
Kubernetes 통합: kubernetes/pkg/storage/etcd/

etcd는 Kubernetes의 모든 클러스터 데이터를 저장하는 분산 키-값 저장소입니다. 클러스터의 모든 상태 및 구성 데이터가 이곳에 저장됩니다.

주요 기능:

• 클러스터 구성 데이터 저장
• 일관성 및 고가용성 제공
• 분산 락 및 리더 선출 기능

3. kube-controller-manager

소스 코드 위치: kubernetes/cmd/kube-controller-manager/
핵심 파일: kubernetes/cmd/kube-controller-manager/controller-manager.go
주요 컨트롤러: kubernetes/pkg/controller/

kube-controller-manager는 여러 컨트롤러 프로세스를 실행하는 컴포넌트입니다. 이 컨트롤러들은 클러스터의 실제 상태가 원하는 상태와 일치하도록 지속적으로 모니터링하고 조정합니다.

주요 컨트롤러:

• 노드 컨트롤러: kubernetes/pkg/controller/node/
• 레플리케이션 컨트롤러: kubernetes/pkg/controller/replication/
• 엔드포인트 컨트롤러: kubernetes/pkg/controller/endpoint/
• 서비스 어카운트 컨트롤러: kubernetes/pkg/controller/serviceaccount/

핵심 코드 구조:

// controller-manager.go에서 컨트롤러 등록 및 실행
func Run(c *config.CompletedConfig, stopCh <-chan struct{}) error {
    // 컨트롤러 컨텍스트 생성
    ctx, cancel := context.WithCancel(context.Background())
    
    // 컨트롤러 초기화 및 실행
    if err := StartControllers(ctx, c, NewControllerInitializers()); err != nil {
        return err
    }
    
    // 컨트롤러 종료 처리
    <-stopCh
    cancel()
    return nil
}

4. kube-scheduler

소스 코드 위치: kubernetes/cmd/kube-scheduler/
핵심 파일: kubernetes/cmd/kube-scheduler/scheduler.go
스케줄링 알고리즘: kubernetes/pkg/scheduler/

kube-scheduler는 새로운 Pod를 적절한 워커 노드에 할당하는 역할을 담당합니다. 이 과정에서 파드의 리소스 요구사항, 하드웨어/소프트웨어 제약 조건, 데이터 지역성 등 다양한 요소를 고려합니다.

주요 기능:

• 노드 필터링 및 점수 계산
• 최적의 노드 선택
• Pod-노드 바인딩

핵심 코드 구조:

// scheduler.go에서 스케줄러 실행
func Run(ctx context.Context, cc *schedulerserverconfig.CompletedConfig, outOfTreeRegistryOptions ...Option) error {
    // 스케줄러 생성
    sched, err := scheduler.New(
        cc.Client,
        cc.InformerFactory,
        cc.PodInformer,
        cc.Recorder,
        ctx.Done(),
        scheduler.WithProfiles(cc.ComponentConfig.Profiles...),
        scheduler.WithAlgorithmSource(cc.ComponentConfig.AlgorithmSource),
        scheduler.WithPercentageOfNodesToScore(cc.ComponentConfig.PercentageOfNodesToScore),
        scheduler.WithFrameworkOutOfTreeRegistry(outOfTreeRegistry),
        scheduler.WithPodMaxBackoffSeconds(cc.ComponentConfig.PodMaxBackoffSeconds),
        scheduler.WithPodInitialBackoffSeconds(cc.ComponentConfig.PodInitialBackoffSeconds),
        scheduler.WithExtenders(cc.ComponentConfig.Extenders...),
    )
    
    // 스케줄러 실행
    return sched.Run(ctx)
}

5. cloud-controller-manager

소스 코드 위치: kubernetes/cmd/cloud-controller-manager/
핵심 파일: kubernetes/cmd/cloud-controller-manager/controller-manager.go
클라우드 제공자 인터페이스: kubernetes/pkg/cloudprovider/

cloud-controller-manager는 클러스터를 클라우드 제공업체의 API와 통합하는 역할을 합니다. 이를 통해 클라우드 제공업체의 서비스(로드 밸런서, 스토리지, 인스턴스 등)를 쿠버네티스 클러스터와 원활하게 연동할 수 있습니다.

주요 기능:

• 클라우드 제공자 API와의 통합
• 노드 컨트롤러의 클라우드 특화 기능
• 라우트 컨트롤러
• 서비스 컨트롤러(로드 밸런서)

워커 노드 컴포넌트 상세 분석

워커 노드는 실제 애플리케이션 컨테이너가 실행되는 쿠버네티스의 작업 단위입니다.

1. kubelet

소스 코드 위치: kubernetes/cmd/kubelet/
핵심 파일: kubernetes/cmd/kubelet/kubelet.go
Pod 관리: kubernetes/pkg/kubelet/

kubelet은 각 노드에서 실행되는 주요 에이전트로, 노드에서 파드와 컨테이너의 생성, 시작, 중지를 관리합니다.

주요 기능:

• Pod 명세에 따른 컨테이너 관리
• 컨테이너 상태 모니터링
• 노드 상태 보고
• 프로브(liveness, readiness) 실행

핵심 코드 구조:

// kubelet.go에서 kubelet 실행
func run(ctx context.Context, s *options.KubeletServer, kubeDeps *kubelet.Dependencies, featureGate featuregate.FeatureGate) error {
    // kubelet 서버 생성
    kubeDeps.KubeClient = k8sclient.NewForConfigOrDie(kubeClientConfig)
    
    // kubelet 생성 및 설정
    k, err := createAndInitKubelet(kubeCfg,
        kubeDeps,
        s.ContainerRuntimeOptions,
        s.ContainerRuntime,
        hostname,
        hostnameOverridden,
        nodeName,
        nodeIPs,
        s.ProviderID,
        cloud,
        s.CertDirectory,
        s.RootDirectory,
        s.ImageCredentialProviderConfigFile,
        s.ImageCredentialProviderBinDir,
        s.RegisterNode,
        s.RegisterWithTaints,
        s.AllowedUnsafeSysctls,
        s.ExperimentalMounterPath,
        s.KernelMemcgNotification,
        s.ExperimentalCheckNodeCapabilitiesBeforeMount,
        s.ExperimentalNodeAllocatableIgnoreEvictionThreshold,
        s.MinimumGCAge,
        s.MaxPerPodContainerCount,
        s.MaxContainerCount,
        s.MasterServiceNamespace,
        s.RegisterSchedulable,
        s.KeepTerminatedPodVolumes,
        s.NodeLabels,
        s.SeccompProfileRoot,
        s.NodeStatusMaxImages,
        s.KubeletFlags.MemorySwap.SwapBehavior,
    )
    
    // kubelet 실행
    startKubelet(k, podCfg, kubeCfg, kubeDeps, s.EnableServer)
    k.Run(podCfg.Updates())
    
    return nil
}

2. kube-proxy

소스 코드 위치: kubernetes/cmd/kube-proxy/
핵심 파일: kubernetes/cmd/kube-proxy/proxy.go
프록시 모드: kubernetes/pkg/proxy/

kube-proxy는 각 노드에서 실행되는 네트워크 프록시로, 쿠버네티스 서비스 개념을 구현합니다.

주요 기능:

• 서비스 IP 라우팅
• 로드 밸런싱
• iptables/IPVS 규칙 관리

핵심 코드 구조:

// proxy.go에서 프록시 서버 실행
func run(o *Options) error {
    // 프록시 서버 구성
    proxyServer, err := NewProxyServer(o)
    if err != nil {
        return err
    }
    
    // 프록시 서버 실행
    return proxyServer.Run()
}

3. 컨테이너 런타임

소스 코드 위치: kubernetes/pkg/kubelet/container/
CRI 구현: kubernetes/pkg/kubelet/cri/

컨테이너 런타임은 컨테이너 실행을 담당하는 소프트웨어입니다. Kubernetes는 CRI(Container Runtime Interface)를 통해 다양한 컨테이너 런타임(Docker, containerd, CRI-O 등)을 지원합니다.

주요 기능:

• 이미지 풀링
• 컨테이너 생성 및 실행
• 컨테이너 상태 관리
• 리소스 격리

핵심 코드 구조:

// CRI 인터페이스 정의
type RuntimeService interface {
    // 컨테이너 생성
    CreateContainer(podSandboxID string, config *ContainerConfig, sandboxConfig *PodSandboxConfig) (string, error)
    
    // 컨테이너 시작
    StartContainer(containerID string) error
    
    // 컨테이너 중지
    StopContainer(containerID string, timeout int64) error
    
    // 컨테이너 제거
    RemoveContainer(containerID string) error
    
    // 컨테이너 상태 조회
    ContainerStatus(containerID string) (*ContainerStatus, error)
}

Pod 생성 워크플로우 심층 분석

Pod 생성 워크플로우는 Kubernetes의 기본적인 작동 방식을 이해하는 데 중요합니다. 아래 시퀀스 다이어그램은 kubectl apply -f pod.yaml 명령이 실행될 때부터 Pod가 노드에서 실행될 때까지의 흐름을 보여줍니다.

1. 사용자 요청 (kubectl)

소스 코드 위치: kubernetes/staging/src/k8s.io/kubectl/pkg/cmd/apply/
핵심 파일: kubernetes/staging/src/k8s.io/kubectl/pkg/cmd/apply/apply.go

사용자가 kubectl apply -f pod.yaml 명령을 실행하면 다음과 같은 과정이 일어납니다:

핵심 코드 구조:

// apply.go에서 리소스 적용 처리
func (o *ApplyOptions) Run() error {
    // 리소스 정보 획득
    infos, err := o.GetObjects()
    if err != nil {
        return err
    }
    
    // 각 리소스에 적용
    for _, info := range infos {
        obj, err := o.patcher.Apply(info)
        if err != nil {
            return err
        }
        
        // 결과 출력 처리
        o.PrintObj(info.Object)
    }
    
    return nil
}

2. API 서버 처리

소스 코드 위치: kubernetes/pkg/registry/core/pod/
핵심 파일: kubernetes/pkg/registry/core/pod/strategy.go
REST 저장소: kubernetes/pkg/registry/core/pod/storage/storage.go

API 서버는 요청을 검증하고 etcd에 저장합니다:

핵심 코드 구조:

// storage.go에서 Pod 생성 처리
func (r *REST) Create(ctx context.Context, obj runtime.Object, createValidation rest.ValidateObjectFunc, options *metav1.CreateOptions) (runtime.Object, error) {
    // 유효성 검사
    pod := obj.(*api.Pod)
    if err := rest.BeforeCreate(pod.Strategy, ctx, obj); err != nil {
        return nil, err
    }
    
    // etcd에 저장
    return r.Store.Create(ctx, obj, createValidation, options)
}

3. 스케줄러 처리

소스 코드 위치: kubernetes/pkg/scheduler/
핵심 파일: kubernetes/pkg/scheduler/scheduler.go
스케줄링 알고리즘: kubernetes/pkg/scheduler/core/generic_scheduler.go

스케줄러는 Pod에 적합한 노드를 선택합니다:

핵심 코드 구조:

// scheduler.go에서 Pod 스케줄링
func (sched *Scheduler) scheduleOne(ctx context.Context) {
    // 스케줄링할 Pod 가져오기
    podInfo, err := sched.NextPod()
    if err != nil {
        return
    }
    
    // 스케줄링 프로파일 선택
    prof, err := sched.profileForPod(podInfo.Pod)
    if err != nil {
        return
    }
    
    // 스케줄링 수행
    scheduleResult, err := sched.Algorithm.Schedule(ctx, prof.SchedulerProfile, state, podInfo.Pod)
    if err != nil {
        return
    }
    
    // 선택된 노드에 Pod 바인딩
    sched.bind(ctx, podInfo, scheduleResult.SuggestedHost, state)
}

4. kubelet의 Pod 실행

소스 코드 위치: kubernetes/pkg/kubelet/pod/
핵심 파일: kubernetes/pkg/kubelet/kubelet.go
Pod 생성: kubernetes/pkg/kubelet/kuberuntime/kuberuntime_manager.go

kubelet은 Pod 명세를 기반으로 컨테이너를 생성하고 실행합니다:

핵심 코드 구조:

// kuberuntime_manager.go에서 Pod 생성
func (m *kubeGenericRuntimeManager) SyncPod(pod *v1.Pod, podStatus *kubecontainer.PodStatus, pullSecrets []v1.Secret, backOff *flowcontrol.Backoff) (result kubecontainer.PodSyncResult) {
    // Pod 샌드박스 생성
    podSandboxID, err := m.createPodSandbox(pod, podContainerChanges.Attempt)
    if err != nil {
        return
    }
    
    // 컨테이너 생성 및 시작
    for _, container := range podContainerChanges.ContainersToStart {
        if err := m.startContainer(podSandboxID, podSandboxConfig, container, pod, podStatus, pullSecrets, podIP, containerType); err != nil {
            continue
        }
    }
    
    return
}

Kubernetes 객체 관계

Kubernetes는 다양한 객체들로 구성되어 있으며, 이들 간에는 명확한 관계가 존재합니다. 우리가 앞서 본 아키텍처 다이어그램은 이러한 주요 객체들과 그들 간의 관계를 보여줍니다.

1. Deployment, ReplicaSet, Pod 관계

소스 코드 위치:
- Deployment: kubernetes/pkg/controller/deployment/
- ReplicaSet: kubernetes/pkg/controller/replicaset/
- Pod: kubernetes/pkg/api/core/types.go

Deployment는, ReplicaSet을 관리하고, ReplicaSet은 Pod의 복제본을 관리합니다.

핵심 코드 구조:

// deployment_controller.go에서 Deployment 처리
func (dc *DeploymentController) syncDeployment(key string) error {
    // Deployment 가져오기
    deployment, err := dc.dLister.Deployments(namespace).Get(name)
    if err != nil {
        return err
    }
    
    // ReplicaSet 관리
    rsList, err := dc.getReplicaSetsForDeployment(deployment)
    if err != nil {
        return err
    }
    
    // 새 ReplicaSet 생성 또는 기존 ReplicaSet 스케일링
    newRS, oldRSs, err := dc.getAllReplicaSetsAndSyncRevision(deployment, rsList, false)
    if err != nil {
        return err
    }
    
    // Deployment 상태 업데이트
    return dc.syncDeploymentStatus(allRSs, newRS, deployment)
}

2. Service와 Pod 관계

소스 코드 위치:
- Service: kubernetes/pkg/registry/core/service/
- Endpoints: kubernetes/pkg/registry/core/endpoint/

Service는 라벨 셀렉터를 통해 Pod 집합에 대한 안정적인 네트워크 엔드포인트를 제공합니다.

핵심 코드 구조:

// endpoints_controller.go에서 Endpoints 관리
func (e *EndpointController) syncService(key string) error {
    // Service 가져오기
    service, err := e.serviceLister.Services(namespace).Get(name)
    if err != nil {
        return err
    }
    
    // Pod 선택
    pods, err := e.podLister.Pods(service.Namespace).List(labels.Set(service.Spec.Selector).AsSelectorPreValidated())
    if err != nil {
        return err
    }
    
    // Endpoints 생성/업데이트
    endpoints := &v1.Endpoints{
        ObjectMeta: metav1.ObjectMeta{
            Name: service.Name,
            Namespace: service.Namespace,
        },
    }
    
    // Pod IP를 Endpoints에 추가
    for _, pod := range pods {
        if isReadyPod(pod) {
            endpoints.Subsets = append(endpoints.Subsets, v1.EndpointSubset{
                Addresses: []v1.EndpointAddress{{IP: pod.Status.PodIP}},
                Ports: getEndpointPorts(service.Spec.Ports),
            })
        }
    }
    
    // Endpoints 업데이트
    return e.client.CoreV1().Endpoints(service.Namespace).Update(context.TODO(), endpoints, metav1.UpdateOptions{})
}

3. PersistentVolume과 PersistentVolumeClaim

소스 코드 위치:
- PV: kubernetes/pkg/controller/volume/persistentvolume/
- PVC: kubernetes/pkg/controller/volume/persistentvolume/pv_controller.go

PVC는 사용자의 스토리지 요청을 나타내고, PV는 관리자가 프로비저닝한 스토리지를 나타냅니다.

핵심 코드 구조:

// pv_controller.go에서 볼륨 바인딩
func (ctrl *PersistentVolumeController) syncClaim(claim *v1.PersistentVolumeClaim) error {
    // PVC 상태 확인
    if claim.Status.Phase != v1.ClaimPending {
        return nil
    }
    
    // 적절한 PV 찾기
    volume, err := ctrl.findBestMatchForClaim(claim)
    if err != nil {
        return err
    }
    
    // PV와 PVC 바인딩
    if volume != nil {
        claimClone, err := ctrl.bindVolumeToClaim(volume, claim)
        if err != nil {
            return err
        }
        
        // 바인딩 정보 업데이트
        _, err = ctrl.kubeClient.CoreV1().PersistentVolumeClaims(claim.Namespace).Update(context.TODO(), claimClone, metav1.UpdateOptions{})
        return err
    }
    
    // 동적 프로비저닝 시도
    return ctrl.provisionClaim(claim)
}

선언적 상태 관리 워크플로우

Kubernetes는 선언적 접근 방식을 사용하여 리소스를 관리합니다. 사용자는 원하는 상태를 YAML 또는 JSON 파일로 정의하고, Kubernetes 시스템이 이를 유지하도록 합니다.

소스 코드 위치: kubernetes/pkg/controller/

조정 루프 (Reconciliation Loop)

// 일반적인 컨트롤러 패턴
func (c *Controller) reconcile(key string) error {
    // 현재 상태 가져오기
    obj, exists, err := c.informer.GetIndexer().GetByKey(key)
    if err != nil {
        return err
    }
    
    if !exists {
        // 객체가 삭제됨 - 정리 작업 수행
        return c.handleDeletion(key)
    }
    
    // 현재 상태와 원하는 상태 비교
    current := obj.(*v1.SomeResource)
    desired := c.computeDesiredState(current)
    
    // 차이가 있으면 원하는 상태로 업데이트
    if !reflect.DeepEqual(current.Spec, desired.Spec) {
        return c.client.Update(context.TODO(), desired)
    }
    
    return nil
}

상태 변화 감지 및 이벤트 처리

컨트롤러는 리소스 변경을 감지하고 대응합니다:

// 이벤트 핸들러 등록
func (c *Controller) Run(workers int, stopCh <-chan struct{}) {
    // 이벤트 핸들러 설정
    c.informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
        AddFunc: func(obj interface{}) {
            key, err := cache.MetaNamespaceKeyFunc(obj)
            if err == nil {
                c.queue.Add(key)
            }
        },
        UpdateFunc: func(old, new interface{}) {
            key, err := cache.MetaNamespaceKeyFunc(new)
            if err == nil {
                c.queue.Add(key)
            }
        },
        DeleteFunc: func(obj interface{}) {
            key, err := cache.DeletionHandlingMetaNamespaceKeyFunc(obj)
            if err == nil {
                c.queue.Add(key)
            }
        },
    })
    
    // 워커 시작
    for i := 0; i < workers; i++ {
        go wait.Until(c.runWorker, time.Second, stopCh)
    }
    
    <-stopCh
}

Ingress 워크플로우

Ingress는 클러스터 외부에서 내부 서비스로의 HTTP/HTTPS 트래픽을 관리합니다.

소스 코드 위치: kubernetes/pkg/registry/networking/ingress/
Ingress 컨트롤러: 외부 프로젝트 (예: kubernetes/ingress-nginx)

Ingress 컨트롤러 워크플로우

// 일반적인 Ingress 컨트롤러 패턴
func (c *IngressController) syncIngress(key string) error {
    // Ingress 객체 가져오기
    ing, err := c.ingressLister.Ingresses(namespace).Get(name)
    if err != nil {
        return err
    }
    
    // 백엔드 서비스 확인
    for _, rule := range ing.Spec.Rules {
        for _, path := range rule.HTTP.Paths {
            svc, err := c.serviceLister.Services(ing.Namespace).Get(path.Backend.ServiceName)
            if err != nil {
                continue
            }
            
            // 로드 밸런서 설정 업데이트
            err = c.updateLoadBalancer(ing, svc, rule.Host, path)
            if err != nil {
                return err
            }
        }
    }
    
    // 상태 업데이트
    return c.updateIngressStatus(ing)
}

외부 요청 처리 흐름

1. 클라이언트가 Ingress 컨트롤러의 로드 밸런서로 요청을 보냅니다.
2. Ingress 컨트롤러는 호스트 이름과 경로를 기반으로 적절한 서비스를 결정합니다.
3. 요청은 해당 서비스의 엔드포인트로 라우팅됩니다.
4. 서비스는 요청을 적절한 Pod로 전달합니다.

운영 고려사항

고가용성 설정

소스 코드 위치: kubernetes/cluster/

프로덕션 환경에서는 컨트롤 플레인 컴포넌트를 여러 서버에 분산시켜 단일 장애점을 방지하는 것이 중요합니다:

# 고가용성 etcd 클러스터 예시
apiVersion: v1
kind: ConfigMap
metadata:
  name: etcd-config
data:
  etcd.yaml: |
    listen-peer-urls: https://0.0.0.0:2380
    listen-client-urls: https://0.0.0.0:2379
    initial-cluster: etcd-0=https://etcd-0.etcd:2380,etcd-1=https://etcd-1.etcd:2380,etcd-2=https://etcd-2.etcd:2380
    initial-cluster-state: new
    initial-cluster-token: etcd-cluster-1
    advertise-client-urls: https://etcd-0.etcd:2379
    name: etcd-0

성능 최적화

소스 코드 위치: kubernetes/pkg/scheduler/

노드 리소스 할당, Pod 배치 전략 등을 최적화하여 클러스터 성능을 향상시킬 수 있습니다:

# 노드 어피니티 설정 예시
apiVersion: v1
kind: Pod
metadata:
  name: performance-pod
spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: node-type
            operator: In
            values:
            - high-performance
  containers:
  - name: app
    image: app:latest

보안

소스 코드 위치: kubernetes/pkg/apis/rbac/

RBAC(Role-Based Access Control), 네트워크 정책, Pod 보안 컨텍스트 등을 통해 클러스터와 애플리케이션을 보호해야 합니다:

# RBAC 설정 예시
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: default
subjects:
- kind: User
  name: jane
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

모니터링 및 로깅

소스 코드 위치: kubernetes/pkg/kubelet/metrics/

Prometheus, Grafana, ELK 스택 등을 활용하여 클러스터와 애플리케이션의 상태를 모니터링하고 로그를 수집하는 것이 중요합니다:

# Prometheus 메트릭 엔드포인트 활성화 예시
apiVersion: v1
kind: Service
metadata:
  name: kube-state-metrics
  namespace: monitoring
  labels:
    app: kube-state-metrics
spec:
  ports:
  - name: http-metrics
    port: 8080
    targetPort: 8080
    protocol: TCP
  selector:
    app: kube-state-metrics

---

이 문서는 Kubernetes의 아키텍처와 워크플로우에 대한 포괄적인 분석을 제공합니다. 각 섹션은 관련 소스 코드 위치와 핵심 코드 구조를 포함하여 시스템의 동작 방식을 깊이 이해할 수 있도록 합니다. 다이어그램과 코드 예제를 통해 복잡한 Kubernetes 시스템을 더 쉽게 파악할 수 있습니다.

Kubernetes는 끊임없이 진화하고 있으므로, 최신 정보는 공식 Kubernetes 문서와 GitHub 리포지토리를 참조하는 것이 좋습니다.