# 실습

### Single-container Pod

1. Pod 생성 

   ```
   cat <<EOF | kubectl apply -f -
   apiVersion: v1
   kind: Pod
   metadata:
     name: nginx
   spec:
     containers:
     - image: nginx
       name: nginx
       volumeMounts:
       - mountPath: /var/log/nginx
         name: log-volume
     volumes:
     - name: log-volume
       emptyDir: {}
   EOF
   ```
2. 배포된 웹서버 호출&#x20;

   ```
   kubectl exec nginx -- curl -s localhost
   ```
3. 웹서버 로그 확인&#x20;

   ```
   kubectl exec nginx -- cat /var/log/nginx/access.log
   ```
4. Pod 삭제&#x20;

   ```
   kubectl delete pod nginx
   ```

### Multi-container Pod

1. Pod 생성&#x20;

   ```
   cat <<EOF | kubectl apply -f -
   apiVersion: v1
   kind: Pod
   metadata:
     name: nginx
   spec:
     containers:
     - image: nginx
       name: nginx
       volumeMounts:
       - mountPath: /var/log/nginx
         name: log-volume
     - image: curlimages/curl
       name: curl
       volumeMounts:
       - mountPath: /data/log
         name: log-volume
     volumes:
     - name: log-volume
       emptyDir: {}
   EOF
   ```
2. Pod 상태 확인&#x20;

   ```
   kubectl get pod nginx --watch
   ```
3. 위의 명령어를 실행하면 아래와 같은 결과를 확인할수 있습니다.

   ```
   NAME    READY   STATUS              RESTARTS   AGE
   nginx   0/2     ContainerCreating   0          6s
   nginx   1/2     Error               0          9s
   nginx   1/2     Error               1 (3s ago)   12s
   nginx   1/2     CrashLoopBackOff    1 (1s ago)   13s
   nginx   1/2     Error               2            30s
   nginx   1/2     CrashLoopBackOff    2 (12s ago)   41s
   ...
   ...
   ```
4. Pod가 정상적으로 실행되지 않는 이유 확인

   ```
   kubectl describe pod nginx
   ```
5. 사용한 컨테이너 이미지에 대한 상세 내용 확인 - <https://hub.docker.com/r/curlimages/curl>
6. Pod 재생성

   ```
   cat <<EOF | kubectl replace --force -f -
   apiVersion: v1
   kind: Pod
   metadata:
     name: nginx
   spec:
     containers:
     - image: nginx
       name: nginx
       volumeMounts:
       - mountPath: /var/log/nginx
         name: log-volume
     - image: curlimages/curl
       name: curl
       command: ["sleep", "3600"] 
       volumeMounts:
       - mountPath: /data/log
         name: log-volume
     volumes:
     - name: log-volume
       emptyDir: {}
   EOF
   ```
7. 생성한 Pod의 명시한 모든 컨테이너가 정상 동작하는지 확인

   ```
   kubectl get pod nginx
   ```
8. *curl* 컨테이너에서 *nginx* 컨테이너에서 실행중인 웹서버 호출

   ```
   kubectl exec nginx -c curl -- curl -s localhost
   ```
9. *nginx* 컨테이너에서 웹서버 로그 확인&#x20;

   ```
   kubectl exec nginx -c nginx -- cat /var/log/nginx/access.log
   ```
10. *curl* 컨테이너에서 마운트한 볼륨에 생성된 파일 확인

    ```
    kubectl exec nginx -c curl -- ls /data/log
    ```
11. *curl* 컨테이너에서 nginx 컨테이너 실행중인 웹서버가 생성한 로그파일 확인

    ```
    kubectl exec nginx -c curl -- cat /data/log/access.log
    ```
12. Pod 삭제&#x20;

    ```
    kubectl delete pod nginx
    ```

### Commands and Arguments

1. Pod 생성&#x20;

   ```
   cat <<EOF | kubectl apply -f -
   apiVersion: v1
   kind: Pod
   metadata:
     name: echo
   spec:
     containers:
     - name: echo 
       image: youngwjung/echo
     restartPolicy: Never
   EOF
   ```
2. Pod에 명시한 이미지는 아래와 같은 Dockerfile을 통해서 생성 되었습니다.

   ```
   FROM alpine
   ENTRYPOINT ["echo"]
   CMD ["hello world"]
   ```
3. 생성된 Pod 확인

   ```
   kubectl get pod echo
   ```
4. Pod 상태 확인

   ```
   kubectl get pod echo -o=jsonpath='{.status.phase}{"\n"}'
   ```
5. 아래의 명령어를 통해서 Pod 상태가 무엇을 의미하는지 확인

   ```
   kubectl explain pod.status.phase
   ```
6. Pod 로그 확인

   ```
   kubectl logs echo
   ```
7. Pod 재생성

   ```
   cat <<EOF | kubectl replace --force -f -
   apiVersion: v1
   kind: Pod
   metadata:
     name: echo
   spec:
     containers:
     - name: echo 
       image: youngwjung/echo
       args: ["welcome to kubernetes"]
     restartPolicy: Never
   EOF
   ```
8. Pod 로그 확인

   ```
   kubectl logs echo
   ```
9. 터미널에서 아래의 같은 명령어를 실행해서 나오는 결과 확인

   ```
   date hello world
   ```
10. Pod 재생성

    ```
    cat <<EOF | kubectl replace --force -f -
    apiVersion: v1
    kind: Pod
    metadata:
      name: echo
    spec:
      containers:
      - name: echo 
        image: youngwjung/echo
        command: ["date"]
      restartPolicy: Never
    EOF
    ```
11. Pod 로그 확인

    ```
    kubectl logs echo
    ```
12. Pod 삭제&#x20;

    ```
    kubectl delete pod echo
    ```

### Pod Networking

1. Pod 생성&#x20;

   ```
   cat <<EOF | kubectl apply -f -
   apiVersion: v1
   kind: Pod
   metadata:
     name: nginx
   spec:
     containers:
     - name: nginx
       image: nginx
       ports:
       - containerPort: 8080
   ---
   apiVersion: v1
   kind: Pod
   metadata:
     name: curl
   spec:
     containers:
     - name: curl
       image: curlimages/curl
       command: ["sleep", "3600"]
   EOF
   ```
2. *nginx* Pod의 IP 주소 확인

   ```
   kubectl get pod nginx -o yaml | grep -i ip
   ```
3. *nginx* Pod의 IP 주소 확인

   ```
   kubectl get pod nginx -o jsonpath='{.status.podIP}{"\n"}' 
   ```
4. *curl* Pod에서 *nginx* Pod 호출 시도&#x20;

   ```
   kubectl exec curl -- \
   curl -s $(kubectl get pod nginx -o jsonpath='{.status.podIP}'):$(kubectl get pod nginx -o jsonpath='{.spec.containers[0].ports[0].containerPort}')
   ```
5. *curl* Pod에서 *nginx* Pod 호출 재시도&#x20;

   ```
   kubectl exec curl -- \
   curl -s $(kubectl get pod nginx -o jsonpath='{.status.podIP}')
   ```
6. Session Manager 플러그인 설치&#x20;

   ```
   {
       curl "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/linux_64bit/session-manager-plugin.rpm" -o "session-manager-plugin.rpm"
       sudo yum install -y session-manager-plugin.rpm
       rm session-manager-plugin.rpm
   }
   ```
7. Node들의 인스턴스 아이디 확인

   ```
   kubectl get node \
   -o jsonpath='{.items[*].spec.providerID}{"\n"}' | grep -E "i-[a-z0-9]+"
   ```
8. *nginx* Pod의 IP 주소 확인

   ```
   kubectl get pod nginx -o jsonpath='{.status.podIP}{"\n"}' 
   ```
9. 한개의 Node로 Session Manager 연결

   ```
   aws ssm start-session --target \
   $(kubectl get node -o jsonpath='{.items[0].spec.providerID}{"\n"}' | grep -oE "i-[a-z0-9]+")
   ```
10. curl 명령어를 통해서 *nginx* Pod의 IP 호출&#x20;

    ```
    curl NGINX_POD_IP
    ```
11. Session Manager 종료

    ```
    exit
    ```
12. Pod 삭제&#x20;

    ```
    kubectl delete pod curl nginx
    ```

### Init Containers

1. Pod 생성&#x20;

   ```
   kubectl run nginx --image=nginx
   ```
2. Pod에 설정된 환경변수 확인&#x20;

   ```
   kubectl exec nginx -- printenv
   ```
3. 웹서버 인덱스 페이지 확인&#x20;

   ```
   kubectl exec nginx -- curl -s localhost
   ```
4. EC2 Metadata를 통해서 Pod가 배포된 Node의 가용영역 확인&#x20;

   ```
   kubectl exec nginx -- \
   curl -s -w "\n" http://169.254.169.254/latest/meta-data/placement/availability-zone
   ```
5. 웹서버 인덱스 페이지 업데이트&#x20;

   ```
   kubectl exec nginx -- \
   bash -c 'echo "welcome to $HOSTNAME in $(curl -s http://169.254.169.254/latest/meta-data/placement/availability-zone)" > /usr/share/nginx/html/index.html'
   ```
6. 웹서버 인덱스 페이지가 업데이트 됐는지 확인&#x20;

   ```
   kubectl exec nginx -- curl -s localhost
   ```
7. Pod 생성&#x20;

   ```
   cat <<'EOF' | kubectl apply -f -
   apiVersion: v1
   kind: Pod
   metadata:
     name: nginx-init
   spec:
     containers:
     - name: nginx
       image: nginx
       ports:
       - containerPort: 80
       volumeMounts:
       - name: html
         mountPath: /usr/share/nginx/html
     initContainers:
     - name: index
       image: curlimages/curl
       command:
         - 'sh'
         - '-c'
         - 'echo "welcome to $HOSTNAME in $(curl -s http://169.254.169.254/latest/meta-data/placement/availability-zone)" > /data/index.html'
       volumeMounts:
       - name: html
         mountPath: /data
     volumes:
     - name: html
       emptyDir: {}
   EOF
   ```
8. Pod가 생성되었는지 확인

   ```
   kubectl get pod nginx-init
   ```
9. Cloud9 인스턴스의 8080 포트를 nginx-int Pod의 80 포트로 포워딩&#x20;

   ```
   kubectl port-forward nginx-init 8080:80
   ```
10. Preview -> Preview Running Application 을 클릭해서 NGINX 웹서버로 접근&#x20;
11. 미리보기 창 및 kubectl port-forward 프로세스 종료
12. Pod 삭제

    ```
    kubectl delete pod nginx nginx-init
    ```

### Logs

1. Pod 생성&#x20;

   ```
   kubectl run nginx --image=nginx
   ```
2. Pod 로그 확인

   ```
   kubectl logs nginx
   ```
3. 웹서버 호출

   ```
   kubectl exec nginx -- \
   bash -c "for i in {1..10}; do curl -s localhost; done"
   ```
4. Pod 로그 확인

   ```
   kubectl logs nginx
   ```
5. 마지막 5줄의 로그를 확인하고 새로운 라인을 표시&#x20;

   ```
   kubectl logs nginx --tail 5 --follow
   ```
6. 새로운 터미널을 열고 웹서버 호출

   ```
   kubectl exec nginx -- \
   bash -c "for i in {1..10}; do curl -s localhost/notexist; done"
   ```
7. 기존 터미널로 돌아와서 새로운 로그가 보이는지 확인
8. Ctrl+C를 입력해서 5번에서 실행한 프로세스 종료
9. Pod가 배포된 Node 확인&#x20;

   ```
   kubectl get pod nginx -o wide
   ```
10. Pod가 배포된 노드의 인스턴스 아이디 확인

    ```
    kubectl get node $(kubectl get pod nginx -o=jsonpath='{.spec.nodeName}') \
    -o jsonpath='{.spec.providerID}{"\n"}' | grep -E "i-[a-z0-9]+"
    ```
11. 다른 터미널로 이동해서 Pod가 배포된 Node로 Session Manager 연결

    ```
    aws ssm start-session --target \
    $(kubectl get node $(kubectl get pod nginx -o=jsonpath='{.spec.nodeName}') -o jsonpath='{.spec.providerID}{"\n"}' | grep -oE "i-[a-z0-9]+")
    ```
12. 실행중인 컨테이너 확인&#x20;

    ```
    sudo nerdctl ps
    ```
13. Pause 컨테이너란??
14. 다른 터미널로 이동해서 컨테이너에 ps 바이너리 설치

    ```
    kubectl exec nginx -- bash -c "apt update && apt install -y procps"
    ```
15. 컨테이너에서 실행중인 프로세스 확인&#x20;

    ```
    kubectl exec nginx -- ps aux
    ```
16. Pod 상태 확인

    ```
    kubectl get pod nginx
    ```
17. Init 프로세스 (PID 1) 종료&#x20;

    ```
    kubectl exec nginx -- kill 1
    ```
18. Pod 상태 확인&#x20;

    ```
    kubectl get pod nginx
    ```
19. Pod 로그 확인

    ```
    kubectl logs nginx
    ```
20. 이전에 종료된 컨테이너 로그 확인&#x20;

    ```
    kubectl logs nginx -p
    ```
21. 생성된 Pod의 재시작 정책 확인

    ```
    kubectl get pod nginx -o yaml | grep -i restartPolicy
    ```
22. 아래의 명령어를 통해서 Pod 재시작 정책이 무엇을 의미하는지 확인

    ```
    kubectl explain pod.spec.restartPolicy
    ```
23. 다른 터미널로 이동해서 crictl 설치&#x20;

    ```
    {
        VERSION="v1.30.0" # check latest version in /releases page
        wget https://github.com/kubernetes-sigs/cri-tools/releases/download/$VERSION/crictl-$VERSION-linux-amd64.tar.gz
        sudo tar zxvf crictl-$VERSION-linux-amd64.tar.gz -C /usr/local/bin
        rm -f crictl-$VERSION-linux-amd64.tar.gz
    }
    ```
24. 실행중인 컨테이너 확인&#x20;

    ```
    sudo crictl ps
    ```
25. *nginx* 컨테이너의 ID 확인

    ```
    {
        sudo crictl ps --name nginx
        sudo crictl ps --name nginx -q
    }
    ```
26. *nginx* 컨테이너의 로그 경로 확인&#x20;

    ```
    sudo crictl inspect -o go-template --template '{{.status.logPath}}' \
    $(sudo crictl ps --name nginx -q)
    ```
27. 컨테이너 로그 확인&#x20;

    ```
    sudo cat $(sudo crictl inspect -o go-template --template '{{.status.logPath}}' \
    $(sudo crictl ps --name nginx -q))
    ```
28. 다른 터미널로 이동해서 Pod 로그 확인&#x20;

    ```
    kubectl logs nginx
    ```
29. 24번 명령어로 확인한 로그와 25번 명령어로 확인한 로그 비교
30. Pod 삭제&#x20;

    ```
    kubectl delete pod nginx
    ```
31. 23번 명령어로 확인한 로그 경로가 여전히 존재하는지 확인

### Environment Variables

1. Pod 생성&#x20;

   ```
   kubectl run mysql --image=mysql
   ```
2. Pod 상태 확인&#x20;

   ```
   kubectl get pod mysql --watch
   ```
3. 위의 명령어를 실행하면 아래와 같은 결과를 확인할수 있습니다.&#x20;

   ```
   NAME    READY   STATUS              RESTARTS   AGE
   mysql   0/1     ContainerCreating   0          6s
   mysql   1/1     Running             0          15s
   mysql   0/1     Error               0          16s
   mysql   0/1     Error               1 (4s ago)   19s
   mysql   0/1     CrashLoopBackOff    1 (1s ago)   20s
   mysql   0/1     Error               2 (17s ago)   36s
   mysql   0/1     CrashLoopBackOff    2 (13s ago)   49s
   ```
4. Pod 로그 확인

   ```
   kubectl logs mysql
   ```
5. kubectl run 명령어의 도움말 확인

   ```
   kubectl run --help
   ```
6. Pod 삭제

   ```
   kubectl delete pod mysql
   ```
7. Pod 재생성

   ```
   kubectl run mysql --image=mysql --env="MYSQL_ROOT_PASSWORD=asdf1234"
   ```
8. Pod 상태 확인&#x20;

   ```
   kubectl get pod mysql
   ```
9. Pod에 설정된 환경변수 확인&#x20;

   ```
   kubectl exec mysql -- printenv
   ```
10. 아래의 명령어를 실행해서 mysql에 접속 시도

    ```
    kubectl exec -it mysql -- mysql -p
    ```
11. Pod 삭제

    ```
    kubectl delete pod mysql
    ```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://kubernetes.youngwjung.com/core-concepts/pod/lab.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.