# 작업 디렉토리 생성
mkdir cicd-labs && cd cicd-labs

# docker-compose.yaml 작성
cat << 'EOT' > docker-compose.yaml
services:
  jenkins:
    container_name: jenkins
    image: jenkins/jenkins
    restart: unless-stopped
    networks:
      - cicd-network
    ports:
      - "8080:8080"
      - "50000:50000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - jenkins_home:/var/jenkins_home

  gogs:
    container_name: gogs
    image: gogs/gogs
    restart: unless-stopped
    networks:
      - cicd-network
    ports:
      - "10022:22"
      - "3000:3000"
    volumes:
      - gogs-data:/data

volumes:
  jenkins_home:
  gogs-data:

networks:
  cicd-network:
    driver: bridge
EOT

# 컨테이너 시작
docker compose up -d

# 상태 확인
docker compose ps

# Jenkins 컨테이너 접속 (root)
docker compose exec --privileged -u root jenkins bash

# Docker CLI 설치
curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null

apt-get update
apt install docker-ce-cli curl tree jq yq gh -y

# Jenkins 사용자에게 Docker 권한 부여
# macOS: docker 그룹 ID = 2000
# Windows WSL2: docker 그룹 ID = 1001 (cat /etc/group | grep docker)
groupadd -g 2000 docker  # macOS
chgrp docker /var/run/docker.sock
usermod -aG docker jenkins

exit

# Jenkins 컨테이너 재시작 (설정 적용)
docker compose restart jenkins

# jenkins 사용자로 docker 명령 실행 확인
docker compose exec jenkins docker ps
docker compose exec jenkins docker info

# macOS: Kind 설치
brew install kind
kind --version

# kubectl 설치
brew install kubernetes-cli
kubectl version --client --output=yaml

# Helm 설치
brew install helm
helm version

# (권장) 유용한 도구 설치
brew install krew          # kubectl 플러그인 관리자
brew install kube-ps1      # 프롬프트에 k8s 컨텍스트 표시
brew install kubectx       # 컨텍스트/네임스페이스 전환
brew install kubecolor     # kubectl 출력 컬러화
brew install stern         # 다중 Pod 로그 보기

# kubectl 단축키 및 kubecolor 설정
echo "alias kubectl=kubecolor" >> ~/.zshrc
echo "compdef kubecolor=kubectl" >> ~/.zshrc

# krew 플러그인 설치
kubectl krew install neat stern

# 환경변수 설정
export KUBECONFIG=$PWD/kubeconfig

# 자신의 PC IP 확인 및 설정
MyIP=192.168.254.106  # 각자 자신의 IP로 변경

# Kind 클러스터 설정 파일 생성
cat << EOF > kind-3node.yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
networking:
  apiServerAddress: "$MyIP"
nodes:
- role: control-plane
  extraPortMappings:
  - containerPort: 30000
    hostPort: 30000
  - containerPort: 30001
    hostPort: 30001
  - containerPort: 30002
    hostPort: 30002
  - containerPort: 30003
    hostPort: 30003
- role: worker
- role: worker
EOF

# 클러스터 생성
kind create cluster --config kind-3node.yaml --name myk8s --image kindest/node:v1.32.2

# 클러스터 확인
kind get clusters
kind get nodes --name myk8s

# 노드 정보 확인
kubectl get nodes -o wide
kubectl get pods -A -o wide

# Docker 네트워크 확인 (기본값: 172.18.0.0/16)
docker network ls | grep kind
docker network inspect kind

# 컨테이너 확인
docker ps | grep myk8s

# Helm 저장소 추가
helm repo add geek-cookbook https://geek-cookbook.github.io/charts/

# kube-ops-view 설치
helm install kube-ops-view geek-cookbook/kube-ops-view \
  --version 1.2.2 \
  --set service.main.type=NodePort,service.main.ports.http.nodePort=30001 \
  --set env.TZ="Asia/Seoul" \
  --namespace kube-system

# 설치 확인
kubectl get deploy,pod,svc,ep -n kube-system -l app.kubernetes.io/instance=kube-ops-view

# 웹 브라우저로 접속
open "http://127.0.0.1:30001/#scale=2"  # macOS
# Windows: http://127.0.0.1:30001/#scale=2

# Jenkins 초기 암호 확인
docker compose exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword
# 출력: 09a21116f3ce4f27a0ede79372febfb1

# Jenkins 웹 접속
open "http://127.0.0.1:8080"  # macOS
# Windows: http://127.0.0.1:8080

# Gogs 웹 접속
open "http://127.0.0.1:3000/install"  # macOS
# Windows: http://127.0.0.1:3000/install

# Git 자격증명 설정
export TOKEN=2cd5d237924f0082af2c44a2467c1dc69fccf943  # 각자 토큰

# dev-app 저장소 클론
git clone http://devops:$TOKEN@192.168.254.124:3000/devops/dev-app.git
cd dev-app

# Git 설정
git config --local user.name "devops"
git config --local user.email "a@a.com"
git config --local init.defaultBranch main
git config --local credential.helper store

# server.py 파일 작성
cat << 'EOF' > server.py
from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
from datetime import datetime
import socket

class RequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/plain')
        self.end_headers()

        now = datetime.now()
        hostname = socket.gethostname()

        response_string = now.strftime("The time is %-I:%M:%S %p, VERSION 0.0.1\n")
        response_string += f"Server hostname: {hostname}\n"

        self.wfile.write(bytes(response_string, "utf-8"))

def startServer():
    try:
        server = ThreadingHTTPServer(("0.0.0.0", 80), RequestHandler)
        print("Listening on " + ":".join(map(str, server.server_address)))
        server.serve_forever()
    except KeyboardInterrupt:
        server.shutdown()

if __name__ == "__main__":
    startServer()
EOF

# Dockerfile 작성
cat << 'EOF' > Dockerfile
FROM python:3.12
ENV PYTHONUNBUFFERED 1
COPY . /app
WORKDIR /app
CMD python3 server.py
EOF

# VERSION 파일 생성
echo "0.0.1" > VERSION

# Git push
git add .
git commit -m "Add dev-app"
git push -u origin main

# Jenkins 컨테이너 접속 (root)
docker compose exec --privileged -u root jenkins bash

# kubectl 설치
# macOS (ARM): arm64
# Windows: amd64
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl"
install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
kubectl version --client --output=yaml

# Helm 설치
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
helm version

exit

# 설치 확인
docker compose exec jenkins kubectl version --client --output=yaml
docker compose exec jenkins helm version

# Docker Hub 계정명 설정
export DHUSER=gasida  # 각자 계정명으로 변경

# Deployment 생성
cat << EOF | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: timeserver
spec:
  replicas: 2
  selector:
    matchLabels:
      pod: timeserver-pod
  template:
    metadata:
      labels:
        pod: timeserver-pod
    spec:
      containers:
      - name: timeserver-container
        image: docker.io/$DHUSER/dev-app:0.0.1
EOF

# 배포 상태 확인
kubectl get deploy,rs,pod -o wide
watch -d kubectl get deploy,pod -o wide

# 에러 확인
kubectl describe pod <pod-name>
# Events:
#   Warning  Failed     Error: ImagePullBackOff
#   pull access denied, repository does not exist or may require authorization

# Docker Hub 자격증명 Secret 생성
export DHUSER=gasida       # 도커 계정
export DHPASS=<your-token> # 도커 토큰

kubectl create secret docker-registry dockerhub-secret \
  --docker-server=https://index.docker.io/v1/ \
  --docker-username=$DHUSER \
  --docker-password=$DHPASS

# Secret 확인
kubectl get secret dockerhub-secret
kubectl describe secret dockerhub-secret

# Deployment 업데이트 (imagePullSecrets 추가)
cat << EOF | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: timeserver
spec:
  replicas: 2
  selector:
    matchLabels:
      pod: timeserver-pod
  template:
    metadata:
      labels:
        pod: timeserver-pod
    spec:
      containers:
      - name: timeserver-container
        image: docker.io/$DHUSER/dev-app:0.0.1
      imagePullSecrets:
      - name: dockerhub-secret
EOF

# 배포 확인
kubectl get deploy,rs,pod -o wide

# Service 생성
cat << EOF | kubectl apply -f -
apiVersion: v1
kind: Service
metadata:
  name: timeserver
spec:
  selector:
    pod: timeserver-pod
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
    nodePort: 30000
  type: NodePort
EOF

# Service 확인
kubectl get svc,ep timeserver -o wide

# ClusterIP로 접속 테스트
kubectl run curl-pod --image=curlimages/curl:latest --command -- /bin/sh -c "while true; do sleep 3600; done"
kubectl exec -it curl-pod -- curl timeserver
kubectl exec -it curl-pod -- curl timeserver.default.svc.cluster.local

# NodePort로 접속 테스트
curl http://127.0.0.1:30000

# 부하분산 확인
for i in {1..100}; do curl -s http://127.0.0.1:30000 | grep hostname; done | sort | uniq -c | sort -nr

# dev-app 저장소에서 VERSION 0.0.2로 업데이트
cd ~/cicd-labs/dev-app

# VERSION 파일 수정
echo "0.0.2" > VERSION

# server.py 수정 (VERSION 0.0.1 → 0.0.2)
sed -i '' 's/VERSION 0.0.1/VERSION 0.0.2/g' server.py

# Git push
git add .
git commit -m "VERSION $(cat VERSION) Changed"
git push -u origin main

# Jenkins에서 이미지 빌드 후...

# Deployment 이미지 업데이트
kubectl set image deployment timeserver timeserver-container=$DHUSER/dev-app:0.0.2

# Rolling Update 과정 관찰
watch "kubectl get deploy,ep timeserver; echo; kubectl get rs,pod"

# 업데이트 결과 확인
kubectl get deploy timeserver
# NAME         READY   UP-TO-DATE   AVAILABLE   AGE
# timeserver   2/2     2            2           10m

curl http://127.0.0.1:30000
# VERSION 0.0.2 확인

# Gogs 컨테이너 접속
docker compose exec gogs bash

# app.ini 편집
vi /data/gogs/conf/app.ini

# [security] 섹션에 추가
[security]
INSTALL_LOCK = true
SECRET_KEY = j2xaUPQcbAEwpIu
LOCAL_NETWORK_ALLOWLIST = 192.168.254.124  # 각자 PC IP

exit

# Gogs 재시작
docker compose restart gogs

# Jenkinsfile 생성 및 push
cd ~/cicd-labs/dev-app
touch Jenkinsfile
# 위 내용 작성

git add Jenkinsfile
git commit -m "Add Jenkinsfile"
git push

# Gogs Webhook 기록 확인
# Jenkins 빌드 자동 트리거 확인
# Docker Hub에 이미지 업로드 확인

# dev-app 저장소에 deploy 디렉토리 생성
cd ~/cicd-labs/dev-app
mkdir deploy

# Blue Deployment
cat << 'EOF' > deploy/echo-server-blue.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: echo-server-blue
spec:
  replicas: 2
  selector:
    matchLabels:
      app: echo-server
      version: blue
  template:
    metadata:
      labels:
        app: echo-server
        version: blue
    spec:
      containers:
      - name: echo-server
        image: hashicorp/http-echo
        args:
        - "-text=Hello from Blue"
        ports:
        - containerPort: 5678
EOF

# Service (초기에는 Blue를 가리킴)
cat << 'EOF' > deploy/echo-server-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: echo-server-service
spec:
  selector:
    app: echo-server
    version: blue
  ports:
  - protocol: TCP
    port: 80
    targetPort: 5678
    nodePort: 30000
  type: NodePort
EOF

# Green Deployment
cat << 'EOF' > deploy/echo-server-green.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: echo-server-green
spec:
  replicas: 2
  selector:
    matchLabels:
      app: echo-server
      version: green
  template:
    metadata:
      labels:
        app: echo-server
        version: green
    spec:
      containers:
      - name: echo-server
        image: hashicorp/http-echo
        args:
        - "-text=Hello from Green"
        ports:
        - containerPort: 5678
EOF

# Git push
git add deploy/
git commit -m "Add echo server yaml"
git push

# 접속 모니터링 (별도 터미널)
while true; do curl -s --connect-timeout 1 http://127.0.0.1:30000; echo; date; echo "------------"; sleep 1; done

# 배포 상태 모니터링 (별도 터미널)
watch -d 'kubectl get deploy -o wide; echo; kubectl get svc,ep echo-server-service -o wide; echo "------------"'

# Jenkins에서 k8s-bluegreen 파이프라인 실행
# 1. Blue 버전 배포 → Hello from Blue 확인
# 2. Green 버전 배포 승인
# 3. Green으로 전환 승인 → Hello from Green 확인
# 4. Blue 제거 또는 롤백 선택

# argocd 네임스페이스 생성
kubectl create ns argocd

# Helm values 파일 작성
cat << 'EOF' > argocd-values.yaml
dex:
  enabled: false

server:
  service:
    type: NodePort
    nodePortHttps: 30002
EOF

# Helm 저장소 추가
helm repo add argo https://argoproj.github.io/argo-helm

# ArgoCD 설치
helm install argocd argo/argo-cd \
  --version 7.7.10 \
  -f argocd-values.yaml \
  --namespace argocd

# 설치 확인
kubectl get pod,svc,ep -n argocd
kubectl get crd | grep argo

# 초기 admin 암호 확인
kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d; echo
# 출력: PCdOlwZT8c4naBWK

# ArgoCD 웹 접속
open "https://127.0.0.1:30002"  # macOS
# Windows: https://127.0.0.1:30002

# 로그인
# Username: admin
# Password: PCdOlwZT8c4naBWK

# ops-deploy 저장소 클론
cd ~/cicd-labs
git clone http://devops:$TOKEN@192.168.254.124:3000/devops/ops-deploy.git
cd ops-deploy

# Git 설정
git config --local user.name "devops"
git config --local user.email "a@a.com"
git config --local init.defaultBranch main
git config --local credential.helper store

# nginx-chart 디렉토리 생성
export VERSION=1.26.1
mkdir -p nginx-chart/templates

# VERSION 파일
echo "$VERSION" > nginx-chart/VERSION

# Chart.yaml
cat << EOF > nginx-chart/Chart.yaml
apiVersion: v2
name: nginx-chart
description: A Helm chart for deploying Nginx with custom index.html
type: application
version: 1.0.0
appVersion: "$VERSION"
EOF

# templates/configmap.yaml
cat << 'EOF' > nginx-chart/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: 
data:
  index.html: |

EOF

# templates/deployment.yaml
cat << 'EOF' > nginx-chart/templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: 
spec:
  replicas: 
  selector:
    matchLabels:
      app: 
  template:
    metadata:
      labels:
        app: 
    spec:
      containers:
      - name: nginx
        image: :
        ports:
        - containerPort: 80
        volumeMounts:
        - name: index-html
          mountPath: /usr/share/nginx/html/index.html
          subPath: index.html
      volumes:
      - name: index-html
        configMap:
          name: 
EOF

# templates/service.yaml
cat << 'EOF' > nginx-chart/templates/service.yaml
apiVersion: v1
kind: Service
metadata:
  name: 
spec:
  selector:
    app: 
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
    nodePort: 30000
  type: NodePort
EOF

# values-dev.yaml (개발 환경)
cat << EOF > nginx-chart/values-dev.yaml
indexHtml: |
  <!DOCTYPE html>
  <html>
  <head>
    <title>Welcome to Nginx!</title>
  </head>
  <body>
    <h1>Hello, Kubernetes!</h1>
    <p>DEV: Nginx version $VERSION</p>
  </body>
  </html>

image:
  repository: nginx
  tag: $VERSION

replicaCount: 1
EOF

# values-prd.yaml (프로덕션 환경)
cat << EOF > nginx-chart/values-prd.yaml
indexHtml: |
  <!DOCTYPE html>
  <html>
  <head>
    <title>Welcome to Nginx!</title>
  </head>
  <body>
    <h1>Hello, Kubernetes!</h1>
    <p>PRD: Nginx version $VERSION</p>
  </body>
  </html>

image:
  repository: nginx
  tag: $VERSION

replicaCount: 2
EOF

# Git push
git add nginx-chart/
git commit -m "Add nginx helm chart"
git push

# dev-nginx Application 생성
cat << 'EOF' | kubectl apply -f -
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: dev-nginx
  namespace: argocd
  finalizers:
  - resources-finalizer.argocd.argoproj.io
spec:
  project: default
  source:
    helm:
      valueFiles:
      - values-dev.yaml
    path: nginx-chart
    repoURL: http://192.168.254.124:3000/devops/ops-deploy
    targetRevision: HEAD
  syncPolicy:
    automated:
      prune: true
    syncOptions:
    - CreateNamespace=true
  destination:
    namespace: dev-nginx
    server: https://kubernetes.default.svc
EOF

# Application 확인
kubectl get applications -n argocd
kubectl describe applications -n argocd dev-nginx

# 배포 확인
kubectl get all -n dev-nginx -o wide
curl http://127.0.0.1:30000

# ops-deploy 저장소에서 VERSION 업데이트
cd ~/cicd-labs/ops-deploy
export VERSION=1.26.2

# VERSION 파일 업데이트
echo "$VERSION" > nginx-chart/VERSION

# values-dev.yaml 업데이트
cat << EOF > nginx-chart/values-dev.yaml
indexHtml: |
  <!DOCTYPE html>
  <html>
  <head>
    <title>Welcome to Nginx!</title>
  </head>
  <body>
    <h1>Hello, Kubernetes!</h1>
    <p>DEV: Nginx version $VERSION</p>
  </body>
  </html>

image:
  repository: nginx
  tag: $VERSION

replicaCount: 2
EOF

# Chart.yaml appVersion 업데이트
sed -i '' "s/appVersion: .*/appVersion: \"$VERSION\"/" nginx-chart/Chart.yaml

# Git push
git add .
git commit -m "Update nginx version $(cat nginx-chart/VERSION)"
git push

# ArgoCD에서 자동 동기화 확인 (최대 3분)
# ArgoCD 웹에서 REFRESH 클릭으로 즉시 확인 가능
kubectl get all -n dev-nginx -o wide
curl http://127.0.0.1:30000

# 동기화 주기 확인
kubectl get cm argocd-cm -n argocd -o yaml | grep timeout.reconciliation
# timeout.reconciliation: 180s

# 즉시 동기화: ArgoCD 웹에서 REFRESH 클릭

# ops-deploy 저장소에 dev-app 디렉토리 생성
cd ~/cicd-labs/ops-deploy
mkdir dev-app

export DHUSER=gasida  # 각자 도커 계정
export VERSION=0.0.3

# VERSION 파일
echo "$VERSION" > dev-app/VERSION

# timeserver.yaml
cat << EOF > dev-app/timeserver.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: timeserver
spec:
  replicas: 2
  selector:
    matchLabels:
      pod: timeserver-pod
  template:
    metadata:
      labels:
        pod: timeserver-pod
    spec:
      containers:
      - name: timeserver-container
        image: docker.io/$DHUSER/dev-app:$VERSION
      imagePullSecrets:
      - name: dockerhub-secret
EOF

# service.yaml
cat << 'EOF' > dev-app/service.yaml
apiVersion: v1
kind: Service
metadata:
  name: timeserver
spec:
  selector:
    pod: timeserver-pod
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
    nodePort: 30000
  type: NodePort
EOF

# Git push
git add dev-app/
git commit -m "Add dev-app deployment yaml"
git push

cat << 'EOF' | kubectl apply -f -
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: timeserver
  namespace: argocd
  finalizers:
  - resources-finalizer.argocd.argoproj.io
spec:
  project: default
  source:
    path: dev-app
    repoURL: http://192.168.254.124:3000/devops/ops-deploy
    targetRevision: HEAD
  syncPolicy:
    automated:
      prune: true
    syncOptions:
    - CreateNamespace=true
  destination:
    namespace: default
    server: https://kubernetes.default.svc
EOF

# 배포 확인
kubectl get applications -n argocd timeserver
kubectl get deploy,rs,pod
kubectl get svc,ep timeserver
curl http://127.0.0.1:30000

# dev-app 저장소의 Jenkinsfile 수정
cd ~/cicd-labs/dev-app

cat << 'EOF' > Jenkinsfile
pipeline {
    agent any

    environment {
        DOCKER_IMAGE = 'gasida/dev-app'  // 각자 도커 계정으로 변경
        GOGSCRD = credentials('gogs-crd')
    }

    stages {
        stage('dev-app Checkout') {
            steps {
                git branch: 'main',
                    url: 'http://192.168.254.124:3000/devops/dev-app.git',
                    credentialsId: 'gogs-crd'
            }
        }

        stage('Read VERSION') {
            steps {
                script {
                    def version = readFile('VERSION').trim()
                    echo "Version found: ${version}"
                    env.DOCKER_TAG = version
                }
            }
        }

        stage('Docker Build and Push') {
            steps {
                script {
                    docker.withRegistry('https://index.docker.io/v1/', 'dockerhub-crd') {
                        def appImage = docker.build("${DOCKER_IMAGE}:${DOCKER_TAG}")
                        appImage.push()
                        appImage.push("latest")
                    }
                }
            }
        }

        stage('ops-deploy Checkout') {
            steps {
                git branch: 'main',
                    url: 'http://192.168.254.124:3000/devops/ops-deploy.git',
                    credentialsId: 'gogs-crd'
            }
        }

        stage('ops-deploy Version Update') {
            steps {
                sh '''
                    OLDVER=$(cat dev-app/VERSION)
                    NEWVER=$(echo ${DOCKER_TAG})

                    sed -i -e "s/$OLDVER/$NEWVER/g" dev-app/timeserver.yaml
                    sed -i -e "s/$OLDVER/$NEWVER/g" dev-app/VERSION

                    git add ./dev-app
                    git config user.name "devops"
                    git config user.email "a@a.com"
                    git commit -m "version update ${DOCKER_TAG}"
                    git push http://${GOGSCRD_USR}:${GOGSCRD_PSW}@192.168.254.124:3000/devops/ops-deploy.git
                '''
            }
        }
    }

    post {
        success {
            echo "Docker image ${DOCKER_IMAGE}:${DOCKER_TAG} has been built and pushed successfully!"
        }
        failure {
            echo "Pipeline failed. Please check the logs."
        }
    }
}
EOF

# Git push
git add Jenkinsfile
git commit -m "Update Jenkinsfile for ops-deploy automation"
git push

# dev-app 저장소에서 VERSION 업데이트
cd ~/cicd-labs/dev-app

# VERSION 0.0.4로 업데이트
echo "0.0.4" > VERSION

# server.py 업데이트
sed -i '' 's/VERSION 0.0.3/VERSION 0.0.4/g' server.py

# Git push
git add .
git commit -m "VERSION $(cat VERSION) Changed"
git push

# Jenkins 자동 빌드 확인
# ops-deploy 저장소 자동 업데이트 확인
# ArgoCD 자동 배포 확인 (3분 이내)
curl http://127.0.0.1:30000

# argo-rollouts 네임스페이스 생성
kubectl create ns argo-rollouts

# Helm values 파일
cat << 'EOF' > argorollouts-values.yaml
dashboard:
  enabled: true
  service:
    type: NodePort
    nodePort: 30003
EOF

# Argo Rollouts 설치
helm install argo-rollouts argo/argo-rollouts \
  --version 2.35.1 \
  -f argorollouts-values.yaml \
  --namespace argo-rollouts

# 설치 확인
kubectl get all -n argo-rollouts

# 대시보드 접속
echo "http://127.0.0.1:30003"
open "http://127.0.0.1:30003"

# Rollout 리소스 배포
kubectl apply -f https://raw.githubusercontent.com/argoproj/argo-rollouts/master/docs/getting-started/basic/rollout.yaml
kubectl apply -f https://raw.githubusercontent.com/argoproj/argo-rollouts/master/docs/getting-started/basic/service.yaml

# Rollout 확인
kubectl get rollout rollouts-demo
kubectl describe rollout rollouts-demo

# Pod 확인
kubectl get pod -l app=rollouts-demo
kubectl get svc,ep rollouts-demo

# 현재 이미지 확인
kubectl get rollouts rollouts-demo -o json | grep -A 2 "image"
# "image": "argoproj/rollouts-demo:blue"

# 새 버전으로 이미지 업데이트
kubectl set image rollout rollouts-demo rollouts-demo=argoproj/rollouts-demo:yellow

# Rollout 상태 확인
kubectl get rollout rollouts-demo
kubectl argo rollouts get rollout rollouts-demo --watch

# 수동 프로모션 (다음 단계 진행)
kubectl argo rollouts promote rollouts-demo

# 롤백
kubectl argo rollouts undo rollouts-demo

# 전체 롤백
kubectl argo rollouts abort rollouts-demo

# Gogs에서 Webhook 추가
# Payload URL: https://<argocd-server>/api/webhook
# Secret: <argocd-webhook-secret>

# 클러스터 생성/삭제
kind create cluster --config kind-3node.yaml --name myk8s
kind delete cluster --name myk8s
kind get clusters

# 이미지 로드 (로컬 이미지를 Kind 클러스터로)
kind load docker-image myapp:latest --name myk8s

# 로그인
argocd login 127.0.0.1:30002

# Application 관리
argocd app list
argocd app get timeserver
argocd app sync timeserver
argocd app diff timeserver
argocd app history timeserver
argocd app rollback timeserver <revision>

# Repository 관리
argocd repo list
argocd repo add <repo-url>

# Rollout 관리
kubectl argo rollouts list rollouts
kubectl argo rollouts get rollout rollouts-demo
kubectl argo rollouts get rollout rollouts-demo --watch

# 배포 제어
kubectl argo rollouts promote rollouts-demo
kubectl argo rollouts undo rollouts-demo
kubectl argo rollouts abort rollouts-demo
kubectl argo rollouts restart rollouts-demo

# 대시보드
kubectl argo rollouts dashboard