CI/CD per Svogliati

# La gerarchia CI/CD
Pipeline          # L'intero processo (1 per push/evento)
  → Stage        # Fase logica (build, test, deploy...)
      → Job     # Singolo compito (compila, linta, testa...)
         → Step # Singola istruzione dentro un job

# Esempio concreto:
Pipeline "Deploy App"
  Stage: Build
      Job: build-frontend    # npm run build
      Job: build-backend     # go build
  Stage: Test
      Job: unit-tests        # pytest
      Job: integration-tests # cypress
  Stage: Deploy
      Job: deploy-staging    # kubectl apply
      Job: deploy-prod       # solo se staging OK

il-tuo-progetto/
 ├── .github/
 │   └── workflows/
 │       ├── ci.yml          # pipeline principale
 │       ├── deploy.yml      # deploy in prod
 │       └── nightly.yml     # test notturni
 ├── src/
 ├── package.json
 └── ...

# Nome del workflow (appare nella tab Actions di GitHub)
name: CI Pipeline

# QUANDO gira questo workflow?
on:
  push:
    branches: [ main, develop ]     # solo su questi branch
  pull_request:
    branches: [ main ]              # PR verso main

# I JOB che compongono il workflow
jobs:
  # --- JOB 1: Build e Test ---
  build-and-test:
    runs-on: ubuntu-latest          # su quale macchina gira

    strategy:
      matrix:
        node-version: [18, 20, 22]   # testa su 3 versioni di Node

    steps:
      # Step 1: Scarica il codice
      - uses: actions/checkout@v4    # action ufficiale di GitHub

      # Step 2: Installa Node.js
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
          cache: 'npm'              # cache le dipendenze

      # Step 3: Installa dipendenze
      - run: npm ci                  # ci = clean install (più veloce)

      # Step 4: Linting
      - run: npm run lint

      # Step 5: Test
      - run: npm test

      # Step 6: Build
      - run: npm run build

      # Step 7: Salva gli artifact
      - uses: actions/upload-artifact@v4
        with:
          name: build-output-${{ matrix.node-version }}
          path: dist/

name: Build & Deploy

on:
  push:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci
      - run: npm test

  build-image:
    needs: test                      # aspetta che test finisca
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: |
          docker build -t myapp:${{ github.sha }} .
          docker push myregistry/myapp:${{ github.sha }}

  deploy-staging:
    needs: build-image
    runs-on: ubuntu-latest
    environment: staging              # protezione ambiente
    steps:
      - run: |
          kubectl set image deployment/myapp \
            myapp=myregistry/myapp:${{ github.sha }}

  deploy-prod:
    needs: deploy-staging
    runs-on: ubuntu-latest
    environment: production           # richiede approvazione manuale
    steps:
      - run: |
          kubectl set image deployment/myapp \
            myapp=myregistry/myapp:${{ github.sha }}

# Le action che userai nel 90% dei workflow

actions/checkout@v4        # clona il repo
actions/setup-node@v4      # installa Node.js
actions/setup-python@v5    # installa Python
actions/setup-go@v5        # installa Go
actions/setup-java@v4      # installa Java
actions/cache@v4           # cache dipendenze (npm, pip, ecc)
actions/upload-artifact@v4 # salva file tra job
actions/download-artifact@v4 # scarica artifact da job precedente
docker/build-push-action@v5 # build + push immagine Docker
docker/login-action@v3     # login a Docker registry

# Definisci l'ordine degli stage
stages:
  - build
  - test
  - deploy

# Variabili globali
variables:
  NODE_VERSION: "20"

# Immagine Docker di default per tutti i job
default:
  image: node:${NODE_VERSION}

# --- STAGE: BUILD ---
build:
  stage: build
  script:
    - npm ci
    - npm run build
  artifacts:                         # passa i file allo stage successivo
    paths:
      - dist/
    expire_in: 1 hour

# --- STAGE: TEST ---
unit-test:
  stage: test
  script:
    - npm ci
    - npm test
  coverage: '/Statements\s*:\s*(\d+\.?\d*)%/'

lint:
  stage: test                        # stesso stage = parallelo a unit-test
  script:
    - npm ci
    - npm run lint

# --- STAGE: DEPLOY ---
deploy-staging:
  stage: deploy
  script:
    - echo "Deploying to staging..."
    - kubectl apply -f k8s/staging/
  environment:
    name: staging
    url: https://staging.example.com
  only:
    - develop

deploy-prod:
  stage: deploy
  script:
    - echo "Deploying to production..."
    - kubectl apply -f k8s/production/
  environment:
    name: production
    url: https://example.com
  only:
    - main
  when: manual                       # richiede click manuale

on:

  # Push su branch specifici
  push:
    branches: [ main, develop ]
    paths:                           # SOLO se questi file cambiano
      - 'src/**'
      - 'package.json'
    paths-ignore:                    # ignora questi
      - 'docs/**'
      - '**.md'

  # Pull request
  pull_request:
    branches: [ main ]
    types: [ opened, synchronize ]   # solo apertura e nuovi push

  # Manuale (bottone "Run workflow")
  workflow_dispatch:
    inputs:
      environment:
        description: 'Target environment'
        required: true
        default: 'staging'
        type: choice
        options:
          - staging
          - production

  # Cron (schedulato)
  schedule:
    - cron: '0 3 * * 1-5'          # lun-ven alle 3:00 UTC

  # Quando viene creato un tag
  push:
    tags:
      - 'v*'                        # v1.0.0, v2.3.1, ecc.

  # Quando un altro workflow finisce
  workflow_run:
    workflows: [ "CI Pipeline" ]
    types: [ completed ]

# GitHub Actions
steps:
  - name: Deploy
    run: |
      echo "Deploying..."
      kubectl apply -f k8s/
    env:
      KUBE_TOKEN: ${{ secrets.KUBE_TOKEN }}        # dal secret store
      REGISTRY_PASS: ${{ secrets.REGISTRY_PASS }}

  - name: Login Docker
    uses: docker/login-action@v3
    with:
      username: ${{ secrets.DOCKER_USER }}
      password: ${{ secrets.DOCKER_PASS }}

# GitLab CI (più semplice, sono già env vars)
deploy:
  script:
    - docker login -u $DOCKER_USER -p $DOCKER_PASS
    - kubectl --token=$KUBE_TOKEN apply -f k8s/

name: Docker Build & Push

on:
  push:
    branches: [ main ]
    tags: [ 'v*' ]

jobs:
  docker:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      # Login al registry
      - uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      # Genera tag intelligenti
      - uses: docker/metadata-action@v5
        id: meta
        with:
          images: ghcr.io/${{ github.repository }}
          tags: |
            type=ref,event=branch
            type=semver,pattern={{version}}
            type=sha

      # Build e push
      - uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          cache-from: type=gha
          cache-to: type=gha,mode=max

name: Python CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.12'
          cache: 'pip'
      - run: pip install -r requirements.txt
      - run: pytest --cov=app tests/

name: Go CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: '1.22'
      - run: go test ./...
      - run: go build -o app .

name: Deploy to GitHub Pages
on:
  push:
    branches: [ main ]
permissions:
  pages: write
  id-token: write
jobs:
  deploy:
    runs-on: ubuntu-latest
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/configure-pages@v4
      - uses: actions/upload-pages-artifact@v3
        with:
          path: '.'
      - uses: actions/deploy-pages@v4
        id: deployment

# === GITHUB ACTIONS (con gh CLI) ===

# Vedi l'ultimo run
gh run list --limit 5

# Vedi i log di un run fallito
gh run view <run-id> --log-failed

# Re-run un workflow fallito
gh run rerun <run-id> --failed

# Disabilita un workflow (emergenza)
gh workflow disable ci.yml

# Triggera manualmente un workflow
gh workflow run deploy.yml -f environment=staging

# === GITLAB CI ===

# Vedi le pipeline recenti
glab ci list

# Vedi i log di un job
glab ci trace <job-id>

# Retrigga una pipeline
glab ci retry <pipeline-id>