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

VM/Container/Pod Resource Tuning: A Comprehensive Production Guide

Learn to tune sysctls, ulimits, cgroups, and Kubernetes resource controls for optimal performance, stability, and security in production workloads.

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.