본문 바로가기
서버구축 (WEB,DB)

Gemini CLI & MCP Agent 활용 Kubernetes 클라우드 자동화 설계 및 배포

by 날으는물고기 2025. 7. 20.

Gemini CLI & MCP Agent 활용 Kubernetes 클라우드 자동화 설계 및 배포

728x90

 

아키텍처 시스템 구성도

핵심 구성 요소

  • Gemini CLI: Google의 AI 모델을 터미널에서 직접 실행
  • MCP (Model Context Protocol): AI 에이전트 통합 및 작업 자동화
  • Kubernetes: 컨테이너 오케스트레이션 플랫폼
  • GitOps: 선언적 인프라 관리 방식
300x250

환경 구성 및 설정

Gemini CLI 설치 및 설정

# Gemini CLI 설치
pip install google-generativeai

# 환경변수 설정 (.zshrc 또는 .bashrc)
export GOOGLE_CLOUD_PROJECT="your-project-id"
export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account-key.json"

# API 활성화 확인
gcloud services enable generativelanguage.googleapis.com

인증 방식별 설정

Vertex AI 인증

# 서비스 계정 생성
gcloud iam service-accounts create gemini-k8s-agent \
    --display-name="Gemini K8s Agent"

# 필요 권한 부여
gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \
    --member="serviceAccount:gemini-k8s-agent@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com" \
    --role="roles/aiplatform.user"

# 키 파일 생성
gcloud iam service-accounts keys create ~/gemini-sa-key.json \
    --iam-account=gemini-k8s-agent@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com

API Key 방식

# Google AI Studio에서 API Key 발급 후
export GEMINI_API_KEY="your-api-key-here"

MCP 에이전트 설정

# mcp-config.yaml
agents:
  k8s-manager:
    type: kubernetes
    capabilities:
      - deploy
      - monitor
      - rollback
    auth:
      method: kubeconfig
      path: ~/.kube/config
    integrations:
      gemini:
        enabled: true
        model: gemini-2.5-pro
      slack:
        webhook_url: ${SLACK_WEBHOOK_URL}

Kubernetes 배포 자동화

자동화 워크플로우

graph LR
    A[요구사항 입력] --> B[Gemini CLI]
    B --> C[YAML 생성]
    C --> D[검증 단계]
    D --> E[MCP Agent]
    E --> F[K8s 배포]
    F --> G[상태 모니터링]
    G --> H[결과 알림]

통합 스크립트 예시

#!/bin/bash
# deploy-with-gemini.sh

# 1. Gemini CLI로 YAML 생성
echo "Nginx 배포를 위한 Kubernetes 매니페스트를 생성해줘. \
      - 2개의 레플리카 \
      - 리소스 제한: CPU 100m, Memory 128Mi \
      - Liveness/Readiness 프로브 포함" | gemini-cli generate > nginx-deployment.yaml

# 2. 생성된 YAML 검증
kubectl --dry-run=client apply -f nginx-deployment.yaml

# 3. MCP 에이전트를 통한 배포
mcp-cli deploy \
  --agent k8s-manager \
  --manifest nginx-deployment.yaml \
  --notify slack \
  --rollback-on-failure

GitOps 연동 구성

# argocd-application.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: gemini-generated-apps
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/company/k8s-manifests
    targetRevision: HEAD
    path: gemini-generated
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

MCP 연동 구성

MCP 에이전트 아키텍처

# mcp-agent-deployment.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: mcp-agent-config
data:
  config.yaml: |
    server:
      host: 0.0.0.0
      port: 8080

    tools:
      - name: kubectl
        path: /usr/local/bin/kubectl
      - name: helm
        path: /usr/local/bin/helm

    gemini:
      model: gemini-2.5-pro
      temperature: 0.3
      max_tokens: 4096

    tasks:
      - id: deploy-workload
        description: "Kubernetes 워크로드 배포"
        steps:
          - generate_yaml
          - validate_yaml
          - apply_manifest
          - check_rollout

      - id: troubleshoot
        description: "K8s 이슈 트러블슈팅"
        steps:
          - analyze_logs
          - suggest_fixes
          - apply_patches

MCP 작업 정의

{
  "task_definitions": [
    {
      "id": "k8s-deploy",
      "name": "Kubernetes 배포 자동화",
      "parameters": {
        "app_name": {"type": "string", "required": true},
        "namespace": {"type": "string", "default": "default"},
        "replicas": {"type": "integer", "default": 1}
      },
      "workflow": [
        {
          "step": "generate",
          "action": "gemini.generate",
          "prompt_template": "Create K8s deployment for {{app_name}} with {{replicas}} replicas"
        },
        {
          "step": "deploy",
          "action": "kubectl.apply",
          "input": "{{generate.output}}"
        },
        {
          "step": "verify",
          "action": "kubectl.wait",
          "condition": "deployment/{{app_name}} --for=condition=available"
        }
      ]
    }
  ]
}

Prometheus & Grafana 배포 실습

단계별 배포 프로세스

Step 1: Namespace 생성

# Gemini CLI 프롬프트
echo "Kubernetes에서 monitoring 네임스페이스를 생성하는 YAML을 만들어줘" | \
  gemini-cli generate > namespace.yaml

# 생성된 YAML 적용
kubectl apply -f namespace.yaml

Step 2: Prometheus 배포

# Gemini CLI로 Prometheus 구성 생성
cat << EOF | gemini-cli generate > prometheus-config.yaml
Kubernetes에서 Prometheus를 배포하기 위한 완전한 매니페스트를 생성해줘:
- ConfigMap: prometheus.yml 설정 포함
- Deployment: 최신 이미지 사용
- Service: ClusterIP 타입
- ServiceAccount와 RBAC 설정
- 기본 스크레이핑 설정: kube-apiserver, nodes, pods, services
- 데이터 보존 기간: 15일
- PersistentVolume 10Gi
EOF

# 검증 및 배포
kubectl apply -f prometheus-config.yaml -n monitoring

Step 3: Grafana 배포

# Grafana 배포 매니페스트 생성
cat << EOF | gemini-cli generate > grafana-deployment.yaml
Grafana를 Kubernetes에 배포하기 위한 매니페스트를 생성해줘:
- Deployment: grafana/grafana:latest 이미지
- Service: LoadBalancer 타입
- ConfigMap: 기본 datasource로 Prometheus 설정
- 초기 admin 비밀번호는 Secret으로 관리
- PersistentVolume 5Gi
EOF

# Secret 생성 (admin 비밀번호)
kubectl create secret generic grafana-admin \
  --from-literal=admin-password=changeme123 \
  -n monitoring

# 배포
kubectl apply -f grafana-deployment.yaml -n monitoring

Step 4: 데이터소스 연동

# Grafana 데이터소스 설정
cat << EOF | gemini-cli generate > grafana-datasource.yaml
Grafana에서 Prometheus를 데이터소스로 자동 설정하는 ConfigMap을 생성해줘:
- 데이터소스 이름: Prometheus
- URL: http://prometheus-service:9090
- 기본 데이터소스로 설정
EOF

kubectl apply -f grafana-datasource.yaml -n monitoring

Step 5: 대시보드 설정

# 기본 대시보드 가져오기
echo "Kubernetes 클러스터 모니터링을 위한 Grafana 대시보드 JSON을 생성해줘. \
      CPU, Memory, Pod 상태, Node 상태를 포함해야 함" | \
  gemini-cli generate > k8s-dashboard.json

# ConfigMap으로 대시보드 저장
kubectl create configmap grafana-dashboards \
  --from-file=k8s-dashboard.json \
  -n monitoring

자동화 스크립트

#!/bin/bash
# deploy-monitoring.sh

set -e

NAMESPACE="monitoring"

# 1. Namespace 생성
echo "Creating namespace..."
gemini-cli prompt "Create K8s namespace YAML for $NAMESPACE" | kubectl apply -f -

# 2. Prometheus 배포
echo "Deploying Prometheus..."
gemini-cli prompt "Generate complete Prometheus deployment for K8s with RBAC, PV, and scraping configs" \
  > prometheus.yaml
kubectl apply -f prometheus.yaml -n $NAMESPACE

# 3. Grafana 배포
echo "Deploying Grafana..."
gemini-cli prompt "Generate Grafana deployment with datasource auto-config for Prometheus" \
  > grafana.yaml
kubectl apply -f grafana.yaml -n $NAMESPACE

# 4. 배포 상태 확인
echo "Waiting for deployments..."
kubectl wait --for=condition=available --timeout=300s \
  deployment/prometheus deployment/grafana -n $NAMESPACE

# 5. 접속 정보 출력
echo "Monitoring stack deployed successfully!"
echo "Grafana URL: http://$(kubectl get svc grafana -n $NAMESPACE -o jsonpath='{.status.loadBalancer.ingress[0].ip}')"

Django 애플리케이션 배포 가이드

Phase 1: Django 애플리케이션 개발

  1. 요구사항 정의
    • Gemini CLI에 프로젝트 요구사항 입력
    • 예: "사용자 관리 기능이 있는 Django REST API 생성"
  2. 코드 생성
    • Django 프로젝트 구조 생성
    • 모델, 뷰, 시리얼라이저 자동 생성
    • 테스트 코드 포함
  3. 로컬 검증
    • 생성된 코드 검토
    • 단위 테스트 실행
    • 필요시 Gemini CLI로 수정 요청

Phase 2: 컨테이너화

  1. Dockerfile 생성
    • Gemini CLI로 최적화된 Dockerfile 생성
    • Multi-stage 빌드 적용
    • 보안 best practice 반영
  2. 이미지 빌드 및 푸시
    • CI/CD 파이프라인 통합
    • 이미지 스캔 및 검증
    • 레지스트리 푸시

Phase 3: Kubernetes 배포

  1. 매니페스트 생성
    • Deployment, Service, ConfigMap, Secret
    • HPA (Horizontal Pod Autoscaler) 설정
    • Ingress 설정
  2. 데이터베이스 연동
    • PostgreSQL StatefulSet 또는 Cloud SQL
    • 마이그레이션 Job 생성
    • 연결 정보 Secret 관리
  3. 배포 실행
    • kubectl 또는 ArgoCD 통한 배포
    • 헬스체크 및 롤아웃 모니터링
    • 자동 롤백 설정

구체적 실행 단계

Step 1: Django 프로젝트 생성

# Gemini CLI로 Django 프로젝트 스캐폴딩
gemini-cli prompt "Create Django project structure with:
- User authentication API
- JWT token support
- PostgreSQL configuration
- Docker support
- Unit tests" --output-dir ./myproject

Step 2: 코드 검토 및 수정

# 생성된 코드 분석
gemini-cli analyze ./myproject --suggest-improvements

# 특정 기능 추가
gemini-cli prompt "Add email verification feature to the Django user model" \
  --context ./myproject

Step 3: Dockerfile 생성

# 최적화된 Dockerfile 생성
gemini-cli prompt "Create production-ready Dockerfile for Django with:
- Python 3.11 slim base
- Non-root user
- Gunicorn server
- Static files handling
- Health check endpoint" > Dockerfile

Step 4: Kubernetes 매니페스트 생성

# 전체 배포 매니페스트 생성
gemini-cli prompt "Generate K8s manifests for Django app:
- Deployment with 3 replicas
- Service and Ingress
- ConfigMap for Django settings
- Secret for database credentials
- HPA with CPU/Memory targets
- PDB for high availability" > k8s-manifests.yaml

Step 5: 데이터베이스 설정

# PostgreSQL 배포 또는 Cloud SQL 연동
gemini-cli prompt "Create K8s manifest for PostgreSQL with:
- StatefulSet configuration
- PersistentVolume 20Gi
- Backup CronJob
- Connection pooling" > postgres.yaml

Step 6: CI/CD 파이프라인

# GitHub Actions 워크플로우 생성
gemini-cli prompt "Create GitHub Actions workflow for Django:
- Test on push
- Build and push Docker image
- Deploy to K8s on main branch
- Rollback on failure" > .github/workflows/deploy.yaml

Step 7: 배포 및 모니터링

# 배포 실행
kubectl apply -f k8s-manifests.yaml
kubectl apply -f postgres.yaml

# 상태 확인
kubectl rollout status deployment/django-app
kubectl logs -f deployment/django-app

# 마이그레이션 실행
kubectl exec -it deployment/django-app -- python manage.py migrate

MCP 통합 자동화

# django-deploy-task.yaml
apiVersion: mcp.io/v1
kind: Task
metadata:
  name: django-full-deploy
spec:
  steps:
    - name: generate-code
      agent: gemini
      action: create-django-project
      parameters:
        requirements: "{{ .Values.requirements }}"

    - name: build-image
      agent: docker
      action: build-and-push
      parameters:
        dockerfile: "{{ .Steps.generate-code.dockerfile }}"
        registry: "{{ .Values.registry }}"

    - name: deploy-k8s
      agent: kubernetes
      action: apply-manifests
      parameters:
        manifests: "{{ .Steps.generate-code.k8s_manifests }}"
        namespace: "{{ .Values.namespace }}"

    - name: run-migrations
      agent: kubernetes
      action: exec-command
      parameters:
        deployment: django-app
        command: "python manage.py migrate"

    - name: health-check
      agent: monitoring
      action: verify-endpoints
      parameters:
        endpoints:
          - "/health"
          - "/api/v1/status"

보안 및 운영 가이드

보안 체크리스트

영역 항목 구현 방안
인증/인가 API 키 관리 Kubernetes Secrets 또는 외부 시크릿 매니저 사용
  서비스 계정 최소 권한 원칙 적용, 각 컴포넌트별 전용 SA
  RBAC 세분화된 Role/RoleBinding 설정
네트워크 Network Policy Pod 간 통신 제한, Ingress/Egress 규칙
  TLS/SSL Cert-manager로 자동 인증서 관리
  Service Mesh Istio/Linkerd로 mTLS 적용
데이터 암호화 etcd 암호화, PV 암호화
  백업 Velero로 클러스터 백업 자동화
  감사 로그 모든 API 호출 로깅 및 분석
컨테이너 이미지 스캔 Trivy, Snyk 통합
  런타임 보안 Falco로 이상 행동 감지
  Pod Security Policy 보안 컨텍스트 강제

운영 모니터링

# monitoring-stack.yaml
monitoring:
  metrics:
    - prometheus:
        retention: 30d
        scrape_interval: 30s
    - grafana:
        dashboards:
          - kubernetes-cluster
          - application-metrics
          - security-events

  logging:
    - elasticsearch:
        retention: 7d
        indices:
          - application-logs
          - audit-logs
          - security-logs
    - fluentd:
        parsers:
          - json
          - multiline
    - kibana:
        dashboards:
          - error-analysis
          - user-activity

  alerting:
    rules:
      - name: high-cpu-usage
        threshold: 80%
        duration: 5m
      - name: pod-restart-loop
        threshold: 3
        duration: 10m
      - name: pv-usage
        threshold: 90%
    channels:
      - slack
      - pagerduty
      - email

운영 자동화 스크립트

#!/bin/bash
# k8s-ops-automation.sh

# 일일 점검 자동화
daily_check() {
    echo "=== K8s Daily Health Check ==="

    # 클러스터 상태
    kubectl get nodes
    kubectl top nodes

    # 워크로드 상태
    kubectl get pods --all-namespaces | grep -v Running

    # 리소스 사용량
    kubectl top pods --all-namespaces --sort-by=cpu

    # PV 사용량
    kubectl get pv -o custom-columns=NAME:.metadata.name,CAPACITY:.spec.capacity.storage,USED:.status.capacity.storage
}

# 자동 스케일링 설정
setup_autoscaling() {
    local app=$1
    local min=$2
    local max=$3

    kubectl autoscale deployment $app \
        --min=$min \
        --max=$max \
        --cpu-percent=70 \
        --memory-percent=80
}

# 백업 실행
backup_cluster() {
    velero backup create daily-backup-$(date +%Y%m%d) \
        --include-namespaces production,staging \
        --ttl 720h
}

재해 복구 계획

# disaster-recovery.yaml
disaster_recovery:
  backup_strategy:
    frequency: daily
    retention: 30_days
    locations:
      - primary: s3://backup-primary
      - secondary: s3://backup-secondary

  restore_priorities:
    - tier1:
        - databases
        - authentication-services
        - core-apis
    - tier2:
        - web-applications
        - background-jobs
    - tier3:
        - monitoring
        - logging

  rto_rpo:
    tier1:
      rto: 15_minutes
      rpo: 1_hour
    tier2:
      rto: 1_hour
      rpo: 4_hours
    tier3:
      rto: 4_hours
      rpo: 24_hours

Gemini CLI와 Kubernetes의 통합은 인프라 자동화의 새로운 패러다임을 제시합니다. AI 기반 코드 생성과 MCP 에이전트를 통한 자동화로 다음과 같은 이점을 얻을 수 있습니다.

  1. 개발 속도 향상: 반복적인 YAML 작성 시간 90% 단축
  2. 일관성 확보: AI가 생성한 표준화된 매니페스트
  3. 오류 감소: 자동 검증 및 롤백 메커니즘
  4. 확장성: MCP 에이전트로 수백 개 애플리케이션 관리 가능
  5. 보안 강화: 보안 best practice 자동 적용

이 가이드의 방법론을 적용하여 조직의 Kubernetes 운영 효율성을 획기적으로 개선할 수 있습니다.

728x90
그리드형(광고전용)

댓글