CI/CD-Pipeline-Optimierung: Build-Zeiten um 70 % reduzieren

Langsame Pipelines killen die Produktivität der Entwickler. Ein 30-minütiger Build bedeutet 30 Minuten Wartezeit pro Deployment. So optimieren Sie Ihren Workflow.

Zuerst analysieren

Alles messen

# GitHub Actions timing
jobs:
  build:
    steps:
      - name: Measure step
        run: echo "::notice::Step completed in $SECONDS seconds"
```text

### Engpässe identifizieren

1. **Installation von Abhängigkeiten** – Macht oft 30-50 % der Build-Zeit aus
2. **Testausführung** – Sequenzielle Tests verschwenden parallele Kapazitäten
3. **Docker-Builds** – Unoptimierte Layer führen zu redundanter Arbeit
4. **Deployment** – Sequenzielle Umgebungen summieren die Verzögerungen auf

## Caching-Strategien

### Dependency Caching

```yaml
- uses: actions/cache@v3
  with:
    path: |
      ~/.npm
      node_modules
    key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
    restore-keys: |
      ${{ runner.os }}-npm-
```text

### Docker Layer Caching

```dockerfile
# Order matters - frequently changing layers last
FROM node:18 AS deps
WORKDIR /app
COPY package*.json ./
RUN npm ci

FROM node:18 AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN npm run build
```text

### GitHub Actions Cache für Docker

```yaml
- uses: docker/setup-buildx-action@v2
- uses: docker/build-push-action@v4
  with:
    cache-from: type=gha
    cache-to: type=gha,mode=max
```text

## Parallele Ausführung

### Matrix-Strategie

```yaml
strategy:
  matrix:
    shard: [1, 2, 3, 4]
steps:
  - run: npm test -- --shard=${{ matrix.shard }}/4
```text

### Parallele Jobs

```yaml
jobs:
  lint:
    runs-on: ubuntu-latest
    steps: [lint steps]

  test-unit:
    runs-on: ubuntu-latest
    steps: [unit test steps]

  test-e2e:
    runs-on: ubuntu-latest
    steps: [e2e steps]

  build:
    needs: [lint, test-unit, test-e2e]
    steps: [build steps]
```text

## Test-Optimierung

### Selektives Testen

```bash
# Only run affected tests
git diff --name-only origin/main | grep '\.ts$' | \
  xargs -I {} npm test -- --findRelatedTests {}
```text

### Test-Parallelisierung

```yaml
# Jest configuration
{
  "maxWorkers": "50%",
  "shard": "1/4"
}
```text

## Ressourcenmanagement

### Passende Runner verwenden
```yaml
# CPU-intensive builds
runs-on: ubuntu-latest-8-cores

# Memory-intensive operations
runs-on: ubuntu-latest-32gb
```text

### Timeout-Management

```yaml
jobs:
  build:
    timeout-minutes: 15
    steps:
      - timeout-minutes: 5
        run: npm run build
```text

## Reale Ergebnisse

| Metrik | Vorher | Nachher | Verbesserung |
| -------- | -------- | ------- | ------------- |
| Gesamte Build-Zeit | 45 min | 12 min | 73% schneller |
| npm install | 8 min | 45 sec | 90% schneller |
| Test-Suite | 20 min | 6 min | 70% schneller |
| Docker build | 12 min | 3 min | 75% schneller |

## Fazit

Optimieren Sie inkrementell. Beginnen Sie mit Caching, fügen Sie Parallelisierung hinzu und führen Sie anschließend ein Fine-Tuning durch. Messen Sie die Ergebnisse vor und nach jeder Änderung.