Python CI/CD 개념 정리

1️⃣ GitHub Actions

GitHub Actions를 사용한 CI/CD 파이프라인 구성이다.

# .github/workflows/python-app.yml
name: Python application

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.9'
    
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install flake8 pytest
        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
    
    - name: Lint with flake8
      run: |
        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
    
    - name: Test with pytest
      run: |
        pytest

✅ 특징:

자동화된 테스트
코드 품질 검사
의존성 관리
간편한 워크플로우 설정
다양한 환경 지원

2️⃣ Jenkins 파이프라인

Jenkins를 사용한 파이프라인 자동화 구성이다.

// Jenkinsfile
pipeline {
    agent any
    
    environment {
        PYTHON_VERSION = '3.9'
    }
    
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
        
        stage('Setup Python') {
            steps {
                sh """
                    pyenv install ${PYTHON_VERSION}
                    pyenv global ${PYTHON_VERSION}
                    python -m pip install --upgrade pip
                """
            }
        }
        
        stage('Install Dependencies') {
            steps {
                sh 'pip install -r requirements.txt'
            }
        }
        
        stage('Run Tests') {
            steps {
                sh 'pytest --junitxml=test-results.xml'
            }
            post {
                always {
                    junit 'test-results.xml'
                }
            }
        }
        
        stage('Build and Deploy') {
            when {
                branch 'main'
            }
            steps {
                sh '''
                    docker build -t myapp:${BUILD_NUMBER} .
                    docker push myapp:${BUILD_NUMBER}
                '''
            }
        }
    }
}

✅ 특징:

단계별 파이프라인
환경 설정 관리
테스트 결과 보고
조건부 배포
플러그인 확장성

3️⃣ GitLab CI/CD

GitLab에서 제공하는 CI/CD 파이프라인 구성이다.

# .gitlab-ci.yml
image: python:3.9

stages:
  - test
  - build
  - deploy

variables:
  PIP_CACHE_DIR: "$CI_PROJECT_DIR/.pip-cache"

cache:
  paths:
    - .pip-cache/

before_script:
  - python -V
  - pip install -r requirements.txt

test:
  stage: test
  script:
    - pytest --cov=.
  coverage: '/TOTAL.+ ([0-9]{1,3}%)/'
  artifacts:
    reports:
      coverage_report:
        coverage_format: cobertura
        path: coverage.xml
        
build:
  stage: build
  script:
    - python setup.py bdist_wheel
  artifacts:
    paths:
      - dist/
    expire_in: 1 week
    
deploy_staging:
  stage: deploy
  script:
    - pip install twine
    - TWINE_PASSWORD=${CI_JOB_TOKEN} TWINE_USERNAME=gitlab-ci-token twine upload --repository-url ${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/pypi dist/*
  only:
    - develop
    
deploy_production:
  stage: deploy
  script:
    - pip install twine
    - twine upload dist/*
  only:
    - main
  when: manual

✅ 특징:

멀티 스테이지 파이프라인
캐시 관리
커버리지 리포트
빌드 아티팩트 보존
환경별 배포 전략

4️⃣ Docker 기반 배포

Docker를 활용한 일관된 환경 구성과 배포 자동화이다.

# docker-compose.ci.yml
version: '3.8'

services:
  test:
    build:
      context: .
      dockerfile: Dockerfile.test
    volumes:
      - .:/app
    command: pytest

  build:
    build:
      context: .
      dockerfile: Dockerfile
    image: ${CI_REGISTRY_IMAGE}:${CI_COMMIT_SHA}
    
  deploy:
    image: ${CI_REGISTRY_IMAGE}:${CI_COMMIT_SHA}
    restart: unless-stopped
    environment:
      - ENVIRONMENT=production
      - DATABASE_URL=${DATABASE_URL}
      - SECRET_KEY=${SECRET_KEY}
    ports:
      - "8000:8000"
    depends_on:
      - db
      
  db:
    image: postgres:13-alpine
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=${DB_PASSWORD}
      - POSTGRES_USER=${DB_USER}
      - POSTGRES_DB=${DB_NAME}
    restart: unless-stopped
    
volumes:
  postgres_data:

Dockerfile 예시:

# Dockerfile
FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

RUN python -m pytest

EXPOSE 8000

CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app:app"]

✅ 특징:

컨테이너화된 테스트
일관된 환경
버전 관리
마이크로서비스 구조 지원
스케일링 용이

5️⃣ 자동화된 테스트와 배포

다양한 테스트 전략과 배포 자동화 구성이다.

# .github/workflows/automated-testing.yml
name: Automated Testing

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main, develop ]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: [3.8, 3.9]

    steps:
    - uses: actions/checkout@v2
    
    - name: Set up Python ${{ matrix.python-version }}
      uses: actions/setup-python@v2
      with:
        python-version: ${{ matrix.python-version }}
    
    - name: Run tests
      run: |
        pytest --cov=./ --cov-report=xml
    
    - name: Upload coverage
      uses: codecov/codecov-action@v2
      with:
        file: ./coverage.xml
        fail_ci_if_error: true
        
  integration-test:
    runs-on: ubuntu-latest
    needs: test
    services:
      postgres:
        image: postgres:13
        env:
          POSTGRES_PASSWORD: postgres
          POSTGRES_USER: postgres
          POSTGRES_DB: test_db
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
          
    steps:
    - uses: actions/checkout@v2
    
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.9'
        
    - name: Install dependencies
      run: |
        pip install -r requirements.txt
        pip install -r requirements-dev.txt
        
    - name: Run integration tests
      run: |
        pytest tests/integration --cov=./ --cov-report=xml
      env:
        DATABASE_URL: postgresql://postgres:postgres@localhost:5432/test_db
        
  deploy:
    runs-on: ubuntu-latest
    needs: [test, integration-test]
    if: github.ref == 'refs/heads/main'
    
    steps:
    - uses: actions/checkout@v2
    
    - name: Deploy to production
      uses: appleboy/ssh-action@master
      with:
        host: ${{ secrets.HOST }}
        username: ${{ secrets.USERNAME }}
        key: ${{ secrets.SSH_KEY }}
        script: |
          cd /opt/app
          git pull
          docker-compose down
          docker-compose up -d --build

✅ 특징:

매트릭스 테스트
커버리지 분석
자동 배포
통합 테스트 환경
실패 시 롤백 전략

6️⃣ 고급 CI/CD 전략

복잡한 프로젝트를 위한 고급 CI/CD 전략이다.

블루/그린 배포:

# .github/workflows/blue-green-deploy.yml
name: Blue-Green Deployment

on:
  push:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    
    - name: Build Docker image
      run: |
        docker build -t myapp:${{ github.sha }} .
        docker tag myapp:${{ github.sha }} myregistry.com/myapp:${{ github.sha }}
        docker push myregistry.com/myapp:${{ github.sha }}
        
  deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
    - name: Deploy new environment
      uses: appleboy/ssh-action@master
      with:
        host: ${{ secrets.PROD_HOST }}
        username: ${{ secrets.USERNAME }}
        key: ${{ secrets.SSH_KEY }}
        script: |
          # 새 환경 배포
          NEW_ENV="green"
          CURRENT_ENV=$(cat /opt/env_status)
          
          if [ "$CURRENT_ENV" = "green" ]; then
            NEW_ENV="blue"
          fi
          
          cd /opt
          docker-compose -f docker-compose.$NEW_ENV.yml down
          
          # 새 이미지로 업데이트
          sed -i "s|image:.*|image: myregistry.com/myapp:${{ github.sha }}|g" docker-compose.$NEW_ENV.yml
          
          # 새 환경 시작
          docker-compose -f docker-compose.$NEW_ENV.yml up -d
          
          # 헬스체크
          sleep 30
          if curl -s http://localhost:8080/health | grep -q "ok"; then
            # 로드밸런서 업데이트
            sed -i "s/proxy_pass http:\/\/[a-z]*_backend/proxy_pass http:\/\/${NEW_ENV}_backend/g" /etc/nginx/conf.d/app.conf
            nginx -s reload
            
            # 현재 환경 업데이트
            echo $NEW_ENV > /opt/env_status
            
            # 이전 환경 종료 (지연 시간 후)
            sleep 60
            docker-compose -f docker-compose.$CURRENT_ENV.yml down
          else
            # 배포 실패 시 롤백
            docker-compose -f docker-compose.$NEW_ENV.yml down
            echo "Deployment failed health check" >&2
            exit 1
          fi

카나리 배포:

# canary_deploy.py
import os
import time
import requests
import subprocess

def deploy_canary():
    """카나리 배포 실행 스크립트"""
    # 카나리 버전 배포 (트래픽의 10%)
    subprocess.run([
        "kubectl", "set", "image", "deployment/app", 
        f"app-container=myregistry.com/myapp:{os.environ['NEW_VERSION']}", 
        "--record"
    ])
    
    # 카나리 비중 설정
    subprocess.run([
        "kubectl", "scale", "deployment/app", "--replicas=10"
    ])
    subprocess.run([
        "kubectl", "scale", "deployment/app-canary", "--replicas=1"
    ])
    
    # 모니터링 기간
    print("Monitoring canary deployment for 15 minutes...")
    for i in range(15):
        # 오류율 확인
        error_rate = check_error_rate()
        if error_rate > 0.01:  # 오류율 1% 초과 시 롤백
            print(f"Error rate too high: {error_rate}, rolling back")
            rollback_canary()
            return False
        
        # 성능 지표 확인
        latency = check_latency()
        if latency > 500:  # 500ms 이상 지연시 롤백
            print(f"Latency too high: {latency}ms, rolling back")
            rollback_canary()
            return False
        
        print(f"Minute {i+1}/15: Metrics within acceptable range")
        time.sleep(60)
    
    # 모든 트래픽을 새 버전으로 전환
    print("Canary deployment successful, switching all traffic to new version")
    subprocess.run([
        "kubectl", "set", "image", "deployment/app", 
        f"app-container=myregistry.com/myapp:{os.environ['NEW_VERSION']}", 
        "--record"
    ])
    
    # 카나리 제거
    subprocess.run([
        "kubectl", "scale", "deployment/app-canary", "--replicas=0"
    ])
    
    return True

def check_error_rate():
    """프로메테우스에서 오류율 확인"""
    response = requests.get(
        "http://prometheus:9090/api/v1/query",
        params={
            "query": 'sum(rate(http_requests_total{status=~"5.."}[5m])) / sum(rate(http_requests_total[5m]))'
        }
    )
    result = response.json()
    return float(result['data']['result'][0]['value'][1])

def check_latency():
    """프로메테우스에서 응답 시간 확인"""
    response = requests.get(
        "http://prometheus:9090/api/v1/query",
        params={
            "query": 'histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le))'
        }
    )
    result = response.json()
    return float(result['data']['result'][0]['value'][1]) * 1000  # ms로 변환

def rollback_canary():
    """카나리 롤백"""
    subprocess.run([
        "kubectl", "scale", "deployment/app-canary", "--replicas=0"
    ])
    print("Canary deployment rolled back")

if __name__ == "__main__":
    deploy_canary()

✅ 특징:

블루/그린 배포
카나리 배포
자동화된 롤백
점진적인 트래픽 이전
지표 기반 배포 결정

7️⃣ CI/CD 모니터링과 보안

CI/CD 파이프라인의 모니터링과 보안 관리 방법이다.

보안 스캔 통합:

# .github/workflows/security-scan.yml
name: Security Scanning

on:
  push:
    branches: [ main, develop ]
  schedule:
    - cron: '0 0 * * *'  # 매일 자정에 실행

jobs:
  dependency-scan:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.9'
    
    - name: Install dependencies
      run: |
        pip install safety bandit
    
    - name: Check for vulnerable dependencies
      run: |
        safety check -r requirements.txt
        
    - name: Static code security analysis
      run: |
        bandit -r . -x tests/

  container-scan:
    runs-on: ubuntu-latest
    needs: dependency-scan
    steps:
    - uses: actions/checkout@v2
    
    - name: Build image
      run: |
        docker build -t myapp:${{ github.sha }} .
    
    - name: Scan container for vulnerabilities
      uses: aquasecurity/trivy-action@master
      with:
        image-ref: 'myapp:${{ github.sha }}'
        format: 'table'
        exit-code: '1'
        severity: 'CRITICAL,HIGH'

파이프라인 모니터링:

# pipeline_monitor.py
import requests
import datetime
import json
import os
from prometheus_client import Counter, Gauge, start_http_server

# Prometheus 메트릭 정의
builds_total = Counter('ci_builds_total', 'Total number of CI builds', ['status', 'branch'])
build_duration = Gauge('ci_build_duration_seconds', 'Duration of CI builds', ['branch'])
test_failures = Counter('ci_test_failures_total', 'Total number of test failures')
deployment_success = Counter('ci_deployments_total', 'Total number of deployments', ['environment', 'status'])

def get_github_builds(owner, repo, token):
    """GitHub Actions 워크플로우 실행 정보 수집"""
    headers = {'Authorization': f'token {token}'}
    url = f'https://api.github.com/repos/{owner}/{repo}/actions/runs'
    
    response = requests.get(url, headers=headers)
    if response.status_code == 200:
        runs = response.json()['workflow_runs']
        
        for run in runs:
            status = run['conclusion'] or 'pending'
            branch = run['head_branch']
            
            # 빌드 카운터 증가
            builds_total.labels(status=status, branch=branch).inc()
            
            # 빌드 시간 측정
            if run['updated_at'] and run['created_at'] and status != 'pending':
                start_time = datetime.datetime.fromisoformat(run['created_at'].replace('Z', '+00:00'))
                end_time = datetime.datetime.fromisoformat(run['updated_at'].replace('Z', '+00:00'))
                duration = (end_time - start_time).total_seconds()
                build_duration.labels(branch=branch).set(duration)
            
            # 테스트 실패 수집
            if status == 'failure':
                # 테스트 실패 상세 정보 가져오기
                jobs_url = f'https://api.github.com/repos/{owner}/{repo}/actions/runs/{run["id"]}/jobs'
                jobs_response = requests.get(jobs_url, headers=headers)
                
                if jobs_response.status_code == 200:
                    jobs = jobs_response.json()['jobs']
                    for job in jobs:
                        if job['conclusion'] == 'failure' and 'test' in job['name'].lower():
                            test_failures.inc()

def get_deployment_status(owner, repo, token, environment):
    """배포 상태 정보 수집"""
    headers = {'Authorization': f'token {token}'}
    url = f'https://api.github.com/repos/{owner}/{repo}/deployments'
    
    response = requests.get(url, headers=headers)
    if response.status_code == 200:
        deployments = response.json()
        
        for deployment in deployments:
            if deployment['environment'] == environment:
                # 배포 상태 가져오기
                status_url = deployment['statuses_url']
                status_response = requests.get(status_url, headers=headers)
                
                if status_response.status_code == 200:
                    statuses = status_response.json()
                    if statuses:
                        latest_status = statuses[0]['state']
                        deployment_success.labels(
                            environment=environment, 
                            status=latest_status
                        ).inc()

def main():
    # Prometheus 메트릭 서버 시작
    start_http_server(8000)
    
    # 환경 변수에서 설정 가져오기
    owner = os.environ.get('GITHUB_OWNER')
    repo = os.environ.get('GITHUB_REPO')
    token = os.environ.get('GITHUB_TOKEN')
    environments = os.environ.get('DEPLOY_ENVIRONMENTS', 'production,staging').split(',')
    
    while True:
        try:
            # GitHub 빌드 정보 수집
            get_github_builds(owner, repo, token)
            
            # 배포 상태 정보 수집
            for env in environments:
                get_deployment_status(owner, repo, token, env)
                
        except Exception as e:
            print(f"Error collecting metrics: {e}")
        
        # 5분마다 데이터 업데이트
        time.sleep(300)

if __name__ == "__main__":
    main()

✅ 특징:

취약점 스캔 통합
의존성 보안 검사
컨테이너 이미지 스캔
파이프라인 성능 모니터링
배포 상태 추적

주요 팁

✅ 모범 사례:

환경 변수 관리: 민감한 정보는 환경 변수나 시크릿으로 안전하게 관리
보안 설정 주의: 빌드 및 배포 과정에서 보안 검사 단계 포함
테스트 자동화: 단위, 통합, E2E 테스트를 자동화하여 품질 보장
배포 전략 수립: 블루/그린, 카나리, 롤링 배포 중 적합한 전략 선택
모니터링 구축: 파이프라인 성능과 배포 결과 모니터링
롤백 계획 수립: 배포 실패 시 자동 또는 수동 롤백 메커니즘 구현
문서화 유지: 파이프라인 구성과 환경 설정 문서화
성능 최적화: 빌드 캐싱, 병렬 작업 활용으로 파이프라인 속도 개선
코드형 인프라: 인프라 구성을 코드로 관리하여 재현성 확보
브랜치 전략: 적절한 Git 브랜치 전략과 PR 정책 수립
진보적 테스트: 점진적으로 복잡한 테스트를 적용하는 전략
아티팩트 관리: 빌드 결과물의 버전 관리와 보관 정책 수립
통합 알림: 파이프라인 결과를 팀 커뮤니케이션 도구에 알림
리소스 제한: CI/CD 환경의 자원 사용량 제한 설정
지속적 개선: 파이프라인 성능과 효율성 정기적 검토 및 개선

KR_CI_CD - somaz94/python-study GitHub Wiki

Python CI/CD 개념 정리

1️⃣ GitHub Actions

2️⃣ Jenkins 파이프라인

3️⃣ GitLab CI/CD

4️⃣ Docker 기반 배포

Dockerfile 예시:

5️⃣ 자동화된 테스트와 배포

6️⃣ 고급 CI/CD 전략

블루/그린 배포:

카나리 배포:

7️⃣ CI/CD 모니터링과 보안

보안 스캔 통합:

파이프라인 모니터링:

주요 팁

⚠️ GitHub.com Fallback ⚠️

KR_CI_CD - somaz94/python-study GitHub Wiki

Python CI/CD 개념 정리

1️⃣ GitHub Actions

2️⃣ Jenkins 파이프라인

3️⃣ GitLab CI/CD

4️⃣ Docker 기반 배포

Dockerfile 예시:

5️⃣ 자동화된 테스트와 배포

6️⃣ 고급 CI/CD 전략

블루/그린 배포:

카나리 배포:

7️⃣ CI/CD 모니터링과 보안

보안 스캔 통합:

파이프라인 모니터링:

주요 팁

⚠️ **GitHub.com Fallback** ⚠️

⚠️ GitHub.com Fallback ⚠️