Kubernetes Pod 시작 시 명령어 실행 방법 - 초기화 및 설정

소개

이 튜토리얼은 Kubernetes 파드 (Pod) 시작 시 명령을 실행하는 방법을 안내합니다. command 및 args 필드를 사용하여 시작 명령을 구성하고, 여러 명령을 실행하며, 시작 실패를 처리하는 방법을 배우게 됩니다. Minikube 를 사용하여 이러한 개념을 직접 실습할 수 있는 로컬 Kubernetes 환경을 만들 것입니다.

이 랩 (lab) 이 끝나면 Kubernetes 파드의 시작 동작을 사용자 정의하고 원활한 애플리케이션 배포를 보장하는 방법을 이해하게 될 것입니다. 이 지식은 Kubernetes 환경에서 컨테이너화된 애플리케이션을 올바르게 구성하는 데 필수적입니다.

Kubernetes 환경 설정

이 단계에서는 Minikube 를 시작하고 이 랩 (lab) 에 필요한 기본적인 Kubernetes 개념을 이해하여 환경을 준비합니다.

Kubernetes 란 무엇인가요?

Kubernetes 는 애플리케이션 컨테이너의 배포, 확장 및 운영을 자동화하도록 설계된 오픈 소스 플랫폼입니다. Kubernetes 의 핵심은 Pod 입니다. Pod 는 생성 및 관리할 수 있는 가장 작은 배포 가능한 단위입니다.

Minikube 시작하기

Minikube 는 Kubernetes 를 로컬에서 실행할 수 있게 해주는 도구입니다. 시작해 보겠습니다.

minikube start --driver=docker

이 명령은 Docker 를 드라이버로 사용하여 로컬 Kubernetes 클러스터를 생성합니다. 시작 프로세스는 필요한 구성 요소를 다운로드하는 데 몇 분 정도 걸릴 수 있습니다.

다음과 유사한 출력을 볼 수 있습니다.

😄  minikube v1.30.1 on Ubuntu 22.04
✨  Using the docker driver based on user configuration
📌  Using Docker driver with root privileges
👍  Starting control plane node minikube in cluster minikube
🚜  Pulling base image ...
🔥  Creating docker container (CPUs=2, Memory=2200MB) ...
🐳  Preparing Kubernetes v1.27.4 on Docker 24.0.4 ...
    ▪ Generating certificates and keys ...
    ▪ Booting up control plane ...
    ▪ Configuring RBAC rules ...
🔎  Verifying Kubernetes components...
🌟  Enabled addons: default-storageclass, storage-provisioner
💡  kubectl not found. If you need it, try: 'minikube kubectl -- get pods -A'
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

설치 확인

Minikube 클러스터의 상태를 확인하여 모든 것이 제대로 작동하는지 확인해 보겠습니다.

minikube status

Minikube 가 실행 중임을 나타내는 출력을 볼 수 있습니다.

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

이제 kubectl (Kubernetes 명령줄 도구) 가 제대로 구성되었는지 확인해 보겠습니다.

kubectl get nodes

Ready 로 나열된 하나의 노드 (Minikube 인스턴스) 를 볼 수 있습니다.

NAME       STATUS   ROLES           AGE     VERSION
minikube   Ready    control-plane   2m15s   v1.27.4

Kubernetes Pod 이해

Pod 는 Kubernetes 애플리케이션의 기본 실행 단위입니다. 각 Pod 는 클러스터에서 실행 중인 프로세스를 나타내며 하나 이상의 컨테이너를 캡슐화합니다. Pod 는 본질적으로 일시적이므로 필요에 따라 생성, 삭제 및 다시 생성될 수 있습니다.

Kubernetes 에서 일반적으로 YAML 파일로 Pod 를 정의합니다. 이 랩 (lab) 에서는 이미 환경에 몇 가지 예제 YAML 파일을 준비했습니다.

이 파일이 있는 디렉토리로 이동해 보겠습니다.

cd ~/project/kubernetes-examples
ls -la

다음 파일을 볼 수 있습니다.

total 20
drwxr-xr-x 2 labex labex 4096 Sep 21 10:00 .
drwxr-xr-x 3 labex labex 4096 Sep 21 10:00 ..
-rw-r--r-- 1 labex labex  193 Sep 21 10:00 basic-pod.yaml
-rw-r--r-- 1 labex labex  254 Sep 21 10:00 liveness-probe-pod.yaml
-rw-r--r-- 1 labex labex  312 Sep 21 10:00 multi-command-pod.yaml
-rw-r--r-- 1 labex labex  263 Sep 21 10:00 startup-command-pod.yaml

이제 환경이 설정되었으므로 Kubernetes Pod 로 작업하고 시작 시 명령을 실행하는 방법을 배울 준비가 되었습니다.

기본 시작 명령으로 첫 번째 Pod 생성하기

이 단계에서는 첫 번째 Kubernetes Pod 를 생성하고 시작 시 명령을 실행하는 방법을 이해합니다. 컨테이너가 시작될 때 실행해야 하는 내용을 정의하는 command 필드를 검토합니다.

기본 Pod 구성 살펴보기

먼저 기본 Pod 의 구성을 살펴보겠습니다. nano 편집기로 basic-pod.yaml 파일을 엽니다.

nano basic-pod.yaml

다음 내용이 포함된 YAML 파일을 볼 수 있습니다.

apiVersion: v1
kind: Pod
metadata:
  name: basic-pod
spec:
  containers:
    - name: ubuntu
      image: ubuntu:20.04
      command: ["/bin/bash", "-c", "echo 'Pod is running' && sleep 3600"]

이 구성은 다음을 정의합니다.

basic-pod라는 Pod
ubuntu:20.04 이미지를 사용하는 ubuntu라는 단일 컨테이너
메시지를 에코하고 3600 초 (1 시간) 동안 대기하는 시작 명령

command 필드는 컨테이너가 시작될 때 실행될 실행 파일을 지정합니다. 이 경우, 실행할 명령 문자열을 전달할 수 있도록 해주는 -c 플래그와 함께 /bin/bash 셸을 실행하고 있습니다.

Ctrl+X를 눌러 nano 편집기를 종료합니다.

Pod 생성하기

Kubernetes 클러스터에서 이 Pod 를 생성해 보겠습니다.

kubectl apply -f basic-pod.yaml

다음과 같은 출력을 볼 수 있습니다.

pod/basic-pod created

Pod 상태 확인

이제 Pod 가 제대로 실행되고 있는지 확인해 보겠습니다.

kubectl get pods

다음과 유사한 출력을 볼 수 있습니다.

NAME        READY   STATUS    RESTARTS   AGE
basic-pod   1/1     Running   0          30s

이는 Pod 가 성공적으로 실행되고 있음을 나타냅니다. READY 아래의 1/1은 예상되는 컨테이너 중 하나가 실행 중임을 의미합니다.

Pod 로그 보기

시작 명령의 출력을 보려면 Pod 의 로그를 확인할 수 있습니다.

kubectl logs basic-pod

다음과 같은 출력을 볼 수 있습니다.

Pod is running

이는 시작 명령이 성공적으로 실행되었음을 확인합니다.

실행 중인 컨테이너 살펴보기

대화형 셸을 실행하여 컨테이너 내부에서 무슨 일이 일어나고 있는지 살펴보겠습니다.

kubectl exec -it basic-pod -- /bin/bash

이제 컨테이너의 셸 내부에 있습니다. 프로세스가 실행 중인지 확인해 보겠습니다.

ps aux

시작 명령의 일부인 sleep 명령이 실행 중인 것을 볼 수 있습니다.

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.0   4112  3372 ?        Ss   10:05   0:00 /bin/bash -c echo 'Pod is running' && sleep 3600
root         7  0.0  0.0   4112  3536 pts/0    Ss   10:06   0:00 /bin/bash
root        14  0.0  0.0   5900  2928 pts/0    R+   10:06   0:00 ps aux
root        15  0.0  0.0   2512   580 ?        S    10:06   0:00 sleep 3600

PID 1 인 프로세스는 시작 명령이고, sleep 3600 명령은 별도의 프로세스로 실행 중입니다.

다음과 같이 입력하여 컨테이너 셸을 종료합니다.

exit

Pod 수명 주기 이해

Pod 를 생성하면 여러 단계를 거칩니다.

Pending: Pod 가 Kubernetes 에 의해 수락되었지만 아직 실행 중이지 않음
Running: Pod 가 모든 컨테이너와 함께 실행 중
Succeeded: Pod 의 모든 컨테이너가 성공적으로 종료됨
Failed: 모든 컨테이너가 종료되었고, 하나 이상의 컨테이너가 실패함
Unknown: Pod 의 상태를 확인할 수 없음

Pod 는 주 프로세스 (sleep 3600) 가 여전히 실행 중이므로 Running 상태입니다. 이 프로세스가 완료되거나 종료되면 Pod 는 종료 코드에 따라 Succeeded 또는 Failed 상태로 전환됩니다.

이제 command 필드를 사용하여 기본 Pod 를 생성하고 시작 시 명령을 실행하는 방법을 이해했습니다.

시작 구성을 위해 Command 및 Args 사용하기

이 단계에서는 Kubernetes Pod 에서 더 복잡한 시작 동작을 구성하기 위해 command 및 args 필드를 함께 사용하는 방법을 배웁니다.

Command 및 Args 이해

Kubernetes 는 컨테이너가 시작될 때 실행되는 명령을 지정하는 두 가지 주요 방법을 제공합니다.

command: 실행할 실행 파일 지정 (Docker 의 ENTRYPOINT 와 유사)
args: 명령에 전달할 인수를 지정 (Docker 의 CMD 와 유사)

이러한 필드를 개별적으로 또는 함께 사용하면 컨테이너가 시작되는 방식을 유연하게 제어할 수 있습니다.

시작 명령 Pod 살펴보기

startup-command-pod.yaml 파일을 살펴보겠습니다.

nano startup-command-pod.yaml

다음 구성을 볼 수 있습니다.

apiVersion: v1
kind: Pod
metadata:
  name: startup-command-pod
spec:
  containers:
    - name: ubuntu
      image: ubuntu:20.04
      command: ["/bin/bash"]
      args:
        ["-c", "echo 'Custom startup message' > /tmp/startup.txt && sleep 3600"]

이 구성에서:

command 필드는 /bin/bash를 실행하려는 것을 지정합니다.
args 필드는 bash 에 전달할 인수, 즉 -c와 명령을 포함하는 문자열을 제공합니다.

이러한 명령과 인수의 분리는 구성을 더 읽기 쉽고 유지 관리 가능하게 만듭니다.

Ctrl+X를 눌러 nano 편집기를 종료합니다.

시작 명령 Pod 생성하기

이 Pod 를 생성해 보겠습니다.

kubectl apply -f startup-command-pod.yaml

다음과 같은 출력을 볼 수 있습니다.

pod/startup-command-pod created

Pod 상태 확인

Pod 가 실행 중인지 확인합니다.

kubectl get pods startup-command-pod

다음과 같은 출력을 볼 수 있습니다.

NAME                  READY   STATUS    RESTARTS   AGE
startup-command-pod   1/1     Running   0          30s

시작 명령 확인

이제 시작 명령이 예상 파일을 생성했는지 확인하여 시작 명령이 올바르게 실행되었는지 확인해 보겠습니다.

kubectl exec startup-command-pod -- cat /tmp/startup.txt

다음과 같은 출력을 볼 수 있습니다.

Custom startup message

이는 명령이 성공적으로 실행되었고 지정된 내용으로 파일을 생성했음을 확인합니다.

Command 와 Args 의 차이점 이해

command와 args 간의 관계를 이해하는 것이 중요합니다.

command만 지정하면 컨테이너 이미지의 기본 ENTRYPOINT 를 재정의합니다.
args만 지정하면 컨테이너 이미지의 기본 CMD 를 재정의합니다.
command와 args를 모두 지정하면 ENTRYPOINT 와 CMD 를 모두 재정의합니다.

Pod 구성을 수정하면 어떻게 되는지 살펴보겠습니다. modified-command-pod.yaml이라는 새 파일을 만듭니다.

nano modified-command-pod.yaml

다음 내용을 추가합니다.

apiVersion: v1
kind: Pod
metadata:
  name: modified-command-pod
spec:
  containers:
    - name: ubuntu
      image: ubuntu:20.04
      command: ["/bin/echo"]
      args: ["This message is printed by echo"]

Ctrl+X를 누른 다음 Y와 Enter를 눌러 저장하고 종료합니다.

이제 이 Pod 를 생성해 보겠습니다.

kubectl apply -f modified-command-pod.yaml

다음과 같은 출력을 볼 수 있습니다.

pod/modified-command-pod created

로그를 확인하여 무슨 일이 일어났는지 확인합니다.

kubectl logs modified-command-pod

다음과 같은 출력을 볼 수 있습니다.

This message is printed by echo

Pod 가 지정된 인수로 /bin/echo 명령을 실행한 다음, echo가 출력을 인쇄한 후 종료되었음을 확인합니다.

Pod 상태를 확인합니다.

kubectl get pods modified-command-pod

다음과 유사한 출력을 볼 수 있습니다.

NAME                   READY   STATUS      RESTARTS   AGE
modified-command-pod   0/1     Completed   0          45s

Completed 상태는 Pod 가 완료될 때까지 실행되었고 성공적으로 종료되었음을 나타냅니다.

이제 Kubernetes Pod 에서 시작 동작을 구성하기 위해 command와 args를 함께 사용하는 방법을 이해했습니다.

여러 명령 실행 및 시작 실패 처리

이 단계에서는 Pod 시작 시 여러 명령을 실행하고 상태 검사를 사용하여 시작 실패를 처리하는 방법을 배웁니다.

여러 명령 실행

컨테이너가 시작될 때 여러 명령을 실행해야 하는 경우가 많습니다. Kubernetes 에서 이를 수행하는 방법에는 여러 가지가 있습니다.

셸 연산자 (&&, ; 등) 를 사용하여 명령을 연결합니다.
스크립트 파일을 사용합니다.
init 컨테이너를 사용합니다.

multi-command-pod.yaml 파일을 검토하여 첫 번째 방법을 살펴보겠습니다.

nano multi-command-pod.yaml

다음과 같은 내용을 볼 수 있습니다.

apiVersion: v1
kind: Pod
metadata:
  name: multi-command-pod
spec:
  containers:
    - name: ubuntu
      image: ubuntu:20.04
      command: ["/bin/bash", "-c"]
      args:
        [
          "echo 'First command' > /tmp/first.txt && echo 'Second command' > /tmp/second.txt && sleep 3600"
        ]

이 구성은 && 연산자를 사용하여 여러 명령을 함께 연결하며, 이전 명령이 성공한 경우에만 각 명령을 실행합니다.

편집기를 종료하려면 Ctrl+X를 누릅니다.

이 Pod 를 생성해 보겠습니다.

kubectl apply -f multi-command-pod.yaml

다음과 같은 출력을 볼 수 있습니다.

pod/multi-command-pod created

이제 생성된 파일을 확인하여 두 명령이 모두 실행되었는지 확인해 보겠습니다.

kubectl exec multi-command-pod -- cat /tmp/first.txt

다음과 같은 출력을 볼 수 있습니다.

First command

그리고 두 번째 파일의 경우:

kubectl exec multi-command-pod -- cat /tmp/second.txt

다음과 같은 출력을 볼 수 있습니다.

Second command

상태 검사를 사용하여 시작 실패 처리

Kubernetes 는 시작 실패를 감지하고 처리하는 메커니즘을 제공합니다.

Liveness Probe (생존 프로브): 컨테이너가 실행 중인지 확인합니다. 그렇지 않은 경우 Kubernetes 가 다시 시작합니다.
Readiness Probe (준비 프로브): 컨테이너가 트래픽을 수신할 준비가 되었는지 확인합니다.
Startup Probe (시작 프로브): 애플리케이션이 시작되었는지 확인합니다. 느리게 시작되는 컨테이너에 유용합니다.

Liveness Probe 를 사용하는 Pod 를 살펴보겠습니다.

nano liveness-probe-pod.yaml

다음과 같은 내용을 볼 수 있습니다.

apiVersion: v1
kind: Pod
metadata:
  name: liveness-probe-pod
spec:
  containers:
    - name: ubuntu
      image: ubuntu:20.04
      command: ["/bin/bash", "-c"]
      args: ["touch /tmp/healthy && sleep 3600"]
      livenessProbe:
        exec:
          command: ["cat", "/tmp/healthy"]
        initialDelaySeconds: 5
        periodSeconds: 5

이 구성에서:

컨테이너는 시작 시 /tmp/healthy 파일을 생성합니다.
Liveness Probe 는 5 초마다 이 파일을 확인합니다.
파일이 없으면 Kubernetes 는 컨테이너가 비정상이라고 간주하고 다시 시작합니다.

편집기를 종료하려면 Ctrl+X를 누릅니다.

이 Pod 를 생성해 보겠습니다.

kubectl apply -f liveness-probe-pod.yaml

다음과 같은 출력을 볼 수 있습니다.

pod/liveness-probe-pod created

Pod 가 실행 중인지 확인합니다.

kubectl get pods liveness-probe-pod

다음과 같은 출력을 볼 수 있습니다.

NAME                 READY   STATUS    RESTARTS   AGE
liveness-probe-pod   1/1     Running   0          30s

이제 상태 검사 파일을 제거하면 어떻게 되는지 살펴보겠습니다.

kubectl exec liveness-probe-pod -- rm /tmp/healthy

약 10 초 동안 기다린 다음 Pod 상태를 다시 확인합니다.

kubectl get pods liveness-probe-pod

컨테이너가 다시 시작되었음을 볼 수 있습니다.

NAME                 READY   STATUS    RESTARTS   AGE
liveness-probe-pod   1/1     Running   1          60s

RESTARTS 횟수가 1 로 증가하여 Kubernetes 가 비정상 상태를 감지하고 컨테이너를 다시 시작했음을 나타냅니다.

상태 검사 파일이 다시 존재하는지 확인해 보겠습니다 (컨테이너가 다시 시작될 때 시작 명령에 의해 다시 생성되었어야 합니다).

kubectl exec liveness-probe-pod -- ls -la /tmp/healthy

파일이 다시 존재하는 것을 볼 수 있습니다.

-rw-r--r-- 1 root root 0 Sep 21 10:30 /tmp/healthy

이는 Kubernetes 가 시작 실패로부터 자동으로 복구하고 애플리케이션의 원하는 상태를 유지하는 방법을 보여줍니다.

사용자 지정 시작 스크립트 생성

더 복잡한 초기화를 위해 사용자 지정 시작 스크립트를 사용하고 싶을 수 있습니다. 시작을 위해 셸 스크립트를 사용하는 Pod 를 만들어 보겠습니다.

nano script-pod.yaml

다음 내용을 추가합니다.

apiVersion: v1
kind: Pod
metadata:
  name: script-pod
spec:
  containers:
    - name: ubuntu
      image: ubuntu:20.04
      command: ["/bin/bash", "-c"]
      args:
        - |
          cat > /tmp/startup.sh << 'EOF'
          #!/bin/bash
          echo "Script started at $(date)" > /tmp/script-log.txt
          echo "Creating configuration files..." >> /tmp/script-log.txt
          mkdir -p /tmp/config
          echo "app_name=MyApp" > /tmp/config/app.conf
          echo "version=1.0" >> /tmp/config/app.conf
          echo "Script completed successfully" >> /tmp/script-log.txt
          EOF
          chmod +x /tmp/startup.sh
          /tmp/startup.sh
          sleep 3600

이 구성은 다음을 수행합니다.

컨테이너에 시작 스크립트를 생성합니다.
실행 가능하게 만듭니다.
스크립트를 실행합니다.
sleep 으로 컨테이너를 계속 실행합니다.

Ctrl+X를 누른 다음 Y와 Enter를 눌러 저장하고 종료합니다.

이 Pod 를 생성해 보겠습니다.

kubectl apply -f script-pod.yaml

다음과 같은 출력을 볼 수 있습니다.

pod/script-pod created

Pod 가 시작될 때까지 잠시 기다린 다음 상태를 확인합니다.

kubectl get pods script-pod

다음과 같은 출력을 볼 수 있습니다.

NAME         READY   STATUS    RESTARTS   AGE
script-pod   1/1     Running   0          30s

이제 스크립트의 출력을 확인해 보겠습니다.

kubectl exec script-pod -- cat /tmp/script-log.txt

다음과 유사한 출력을 볼 수 있습니다.

Script started at Tue Sep 21 10:35:42 UTC 2023
Creating configuration files...
Script completed successfully

그리고 구성 파일이 생성되었는지 확인해 보겠습니다.

kubectl exec script-pod -- cat /tmp/config/app.conf

다음과 같은 출력을 볼 수 있습니다.

app_name=MyApp
version=1.0

이는 Kubernetes 에서 복잡한 시작 스크립트를 사용하여 컨테이너를 초기화하는 방법을 보여줍니다.

모범 사례 및 실제 적용 사례

이 마지막 단계에서는 Kubernetes Pod 에서 시작 시 명령을 실행하기 위한 모범 사례를 살펴보고 이러한 사례를 구현하는 실제 애플리케이션 예제를 만들 것입니다.

시작 명령에 대한 모범 사례

Kubernetes Pod 에 대한 시작 명령을 구성할 때 다음 모범 사례를 고려하십시오.

시작 명령을 멱등성 (idempotent) 으로 유지: 명령은 문제를 일으키지 않고 여러 번 실행해도 안전해야 합니다.
상태 검사 사용: 성공적인 시작을 확인하기 위해 Liveness Probe (생존 프로브) 및 Readiness Probe (준비 프로브) 를 구현합니다.
실패를 적절하게 처리: 시작 스크립트에 오류 처리를 포함합니다.
관심사 분리: 주 애플리케이션과 별도로 초기화 작업을 위해 init 컨테이너를 사용합니다.
시작 시간 제한: 배포 시간을 줄이기 위해 초기화를 빠르게 유지합니다.
환경 변수 사용: 환경 변수를 통해 시작 명령을 구성할 수 있도록 합니다.
시작 진행 상황 로깅: 문제 해결을 위해 명확한 로그를 출력합니다.

시작 작업을 위해 Init 컨테이너 사용

Init 컨테이너는 앱 컨테이너가 시작되기 전에 실행되며 설정 작업에 이상적입니다. Init 컨테이너가 있는 Pod 를 만들어 보겠습니다.

nano init-container-pod.yaml

다음 내용을 추가합니다.

apiVersion: v1
kind: Pod
metadata:
  name: init-container-pod
spec:
  initContainers:
    - name: init-config
      image: ubuntu:20.04
      command: ["/bin/bash", "-c"]
      args:
        - |
          echo "Initializing configuration..."
          mkdir -p /work-dir/config
          echo "database_url=mysql://user:password@db:3306/mydb" > /work-dir/config/db.conf
          echo "api_key=1234567890" > /work-dir/config/api.conf
          echo "Initialization complete"
      volumeMounts:
        - name: shared-volume
          mountPath: /work-dir
  containers:
    - name: app
      image: ubuntu:20.04
      command: ["/bin/bash", "-c"]
      args:
        - |
          echo "Application starting..."
          echo "Reading configuration:"
          cat /work-dir/config/db.conf
          cat /work-dir/config/api.conf
          echo "Application running..."
          sleep 3600
      volumeMounts:
        - name: shared-volume
          mountPath: /work-dir
  volumes:
    - name: shared-volume
      emptyDir: {}

이 구성에서:

init 컨테이너 init-config가 먼저 실행되고 구성 파일을 생성합니다.
두 컨테이너 모두 shared-volume이라는 볼륨을 공유합니다.
주 앱 컨테이너는 init 컨테이너에서 생성된 구성을 읽습니다.

Ctrl+X를 누른 다음 Y와 Enter를 눌러 저장하고 종료합니다.

이 Pod 를 생성해 보겠습니다.

kubectl apply -f init-container-pod.yaml

다음과 같은 출력을 볼 수 있습니다.

pod/init-container-pod created

Pod 상태를 확인합니다.

kubectl get pods init-container-pod

Pod 가 실행 중임을 볼 수 있습니다.

NAME                 READY   STATUS    RESTARTS   AGE
init-container-pod   1/1     Running   0          30s

이제 주 컨테이너의 로그를 확인해 보겠습니다.

kubectl logs init-container-pod -c app

다음과 유사한 출력을 볼 수 있습니다.

Application starting...
Reading configuration:
database_url=mysql://user:password@db:3306/mydb
api_key=1234567890
Application running...

이는 init 컨테이너가 구성 파일을 성공적으로 생성했고 주 컨테이너가 이를 읽을 수 있었음을 확인합니다.

실제 예: 데이터베이스 검사가 있는 웹 애플리케이션

더 현실적인 예제를 만들어 보겠습니다. 시작하기 전에 데이터베이스 가용성을 확인하는 웹 애플리케이션입니다.

nano webapp-pod.yaml

다음 내용을 추가합니다.

apiVersion: v1
kind: Pod
metadata:
  name: webapp-pod
spec:
  initContainers:
    - name: wait-for-db
      image: busybox:1.28
      command: ["/bin/sh", "-c"]
      args:
        - |
          echo "Checking for database availability..."
          ## In a real scenario, this would check an actual database
          ## For this example, we'll simulate success after a short delay
          sleep 5
          echo "Database is available"
          touch /tmp/db-ready
      volumeMounts:
        - name: shared-volume
          mountPath: /tmp
  containers:
    - name: webapp
      image: nginx:1.19
      ports:
        - containerPort: 80
      command: ["/bin/sh", "-c"]
      args:
        - |
          if [ -f /tmp/db-ready ]; then
            echo "Database connection verified, starting web application..."
            ## Customize nginx configuration
            echo "<h1>Web Application Started Successfully</h1>" > /usr/share/nginx/html/index.html
            echo "<p>Connected to database</p>" >> /usr/share/nginx/html/index.html
            ## Start nginx
            nginx -g 'daemon off;'
          else
            echo "Error: Database not available"
            exit 1
          fi
      volumeMounts:
        - name: shared-volume
          mountPath: /tmp
      readinessProbe:
        httpGet:
          path: /
          port: 80
        initialDelaySeconds: 5
        periodSeconds: 5
  volumes:
    - name: shared-volume
      emptyDir: {}

이 구성은 다음을 수행합니다.

데이터베이스 가용성을 확인하기 위해 init 컨테이너를 사용합니다 (시뮬레이션).
주 컨테이너는 시작하기 전에 init 컨테이너에서 생성된 파일을 확인합니다.
애플리케이션이 트래픽을 제공하는지 확인하기 위해 Readiness Probe (준비 프로브) 를 포함합니다.
컨테이너 간 통신을 위해 공유 볼륨을 사용합니다.

Ctrl+X를 누른 다음 Y와 Enter를 눌러 저장하고 종료합니다.

이 Pod 를 생성해 보겠습니다.

kubectl apply -f webapp-pod.yaml

다음과 같은 출력을 볼 수 있습니다.

pod/webapp-pod created

Pod 가 완전히 시작될 때까지 잠시 기다린 다음 상태를 확인합니다.

kubectl get pods webapp-pod

다음과 같은 출력을 볼 수 있습니다.

NAME         READY   STATUS    RESTARTS   AGE
webapp-pod   1/1     Running   0          30s

READY 열의 1/1은 Readiness Probe (준비 프로브) 가 성공했음을 나타냅니다.

웹 애플리케이션에 액세스하기 위해 포트 포워딩을 해보겠습니다.

kubectl port-forward webapp-pod 8080:80 &

이 명령은 백그라운드에서 실행됩니다 ( & 때문). 이제 curl을 사용하여 웹 애플리케이션에 액세스할 수 있습니다.

curl http://localhost:8080

다음과 같은 출력을 볼 수 있습니다.

<h1>Web Application Started Successfully</h1>
<p>Connected to database</p>

이는 애플리케이션이 올바르게 초기화되었고, 데이터베이스 가용성을 확인했으며, 이제 트래픽을 제공하고 있음을 확인합니다.

포트 포워딩 프로세스를 중지합니다.

pkill -f "kubectl port-forward"

정리

랩을 마치기 전에 생성한 리소스를 정리해 보겠습니다.

kubectl delete pod basic-pod startup-command-pod modified-command-pod multi-command-pod liveness-probe-pod script-pod init-container-pod webapp-pod

다음과 같은 출력을 볼 수 있습니다.

pod "basic-pod" deleted
pod "startup-command-pod" deleted
pod "modified-command-pod" deleted
pod "multi-command-pod" deleted
pod "liveness-probe-pod" deleted
pod "script-pod" deleted
pod "init-container-pod" deleted
pod "webapp-pod" deleted

이제 Kubernetes Pod 에서 시작 시 명령을 실행하고, 여러 명령을 실행하고, 실패를 처리하고, 실제 시나리오에서 모범 사례를 적용하는 방법을 배웠습니다.

요약

이 랩에서는 Kubernetes Pod 에서 시작 시 명령을 실행하는 방법을 배웠습니다. 다음 사항에 대한 실질적인 경험을 얻었습니다.

Minikube 를 사용하여 Kubernetes 환경 설정
특정 시작 명령으로 Pod 생성 및 관리
command 및 args 필드를 사용하여 컨테이너 동작 구성
셸 연산자 및 스크립트를 사용하여 여러 명령 실행
상태 검사를 사용하여 시작 실패 처리
init 컨테이너를 사용하여 모범 사례 구현
적절한 초기화가 필요한 실제 애플리케이션 구축

이러한 기술은 Kubernetes 환경에서 컨테이너화된 애플리케이션을 배포하는 데 필수적입니다. 시작 명령을 적절하게 구성하면 애플리케이션이 올바르게 초기화되고, 종속성을 확인하며, 오류를 적절하게 처리할 수 있습니다.

Kubernetes 여정을 계속 진행하면서, 적절한 애플리케이션 초기화가 안정적이고, 확장 가능하며, 유지 관리 가능한 시스템을 구축하는 데 중요한 부분임을 기억하십시오.