Case Study: Automatyzacja Certyfikatów w Firmie E-commerce

47 tysięcy dolarów strat w dwie godziny. Tyle kosztował jeden wygasły certyfikat SSL w firmie e-commerce, z którą pracowaliśmy. Nie było żadnych alertów, nikt nie wiedział że certyfikat wygasał - był po prostu zanurzony w chaosie 200+ aplikacji zarządzanych przez kilka różnych zespołów. To studium przypadku o tym, jak zamienić ten chaos w porządek - i przy okazji zaoszczędzić ponad 88 tysięcy dolarów rocznie.

Stan wyjściowy był typowy dla szybko rosnących organizacji: dobre intencje, słaba organizacja. Certyfikaty rozrzucone po różnych systemach, brak centralnej widoczności, ręczne procesy, które nikt nie chciał robić.

Wyzwanie: Chaos Certyfikatów

Firma działała w środowisku, które zna chyba każdy cloud-native team: wiele platform, wiele zespołów, każdy ze swoimi nawykami. Efekt? 200+ aplikacji w chmurze (AWS, Azure, GCP), 15 klastrów Kubernetes z 500+ podami, masa legacy VMs i multi-cloud architektura, której nikt nie ogarniał w całości.

Kluczowy Incydent

W lipcu 2023 wygasł certyfikat dla głównego checkout flow. Skutki były dotkliwe - 2 godziny przestoju podczas szczytu sprzedaży, 47 tysięcy dolarów strat, 23% klientów porzuciło koszyki. Dodatkowy negatywny wpływ na SEO i utrata zaufania klientów. Root cause? Certyfikat został odnowiony, ale nie zainstalowany na load balancerze.

Rozwiązanie: Trzyetapowa Transformacja

Etap 1: Inwentaryzacja (2 tygodnie)

Cel: Zrozumieć co mamy

Działania:

1. Automatyczne skanowanie

# Script do discovery
#!/bin/bash
for domain in $(cat domains.txt); do
  echo "Checking $domain..."
  echo | openssl s_client -connect $domain:443 2>/dev/null | \
    openssl x509 -noout -subject -dates -issuer >> inventory.txt
done

2. Import do spreadsheet

• Domena
• Data wygaśnięcia
• Wystawca (CA)
• Właściciel/zespół
• Środowisko (prod/staging/dev)
• Platforma (K8s/VM/Serverless)

Wynik: 237 certyfikatów zidentyfikowanych!

• 18 certyfikatów wygasło (!)
• 42 certyfikaty z < 30 dni do wygaśnięcia
• 89 różnych domen
• 12 różnych CA używanych

Dobry monitoring to fundament - nie tylko podczas inwentaryzacji, ale przez cały czas życia infrastruktury. Jeśli planujesz podobną transformację, koniecznie zapoznaj się z kompletnym stackiem monitoringu certyfikatów SSL z Prometheus i Grafana - to właśnie tej konfiguracji używano w tym projekcie.

Etap 2: Quick Wins (1 miesiąc)

Cel: Stabilizacja i podstawowy monitoring

2.1 Konsolidacja CA

Przed:

• DigiCert: $8,500/rok
• Sectigo: $3,200/rok
• GoDaddy: $2,100/rok
• RapidSSL: $1,500/rok
• Total: $15,300/rok

Po (Let’s Encrypt):

• Total: $0/rok ✓

Oszczędność: $15,300/rok

2.2 Monitoring Setup

Wdrożenie CrtMgr + własny monitoring:

# Prometheus alerts
- alert: CertificateExpiringIn30Days
  expr: (ssl_cert_not_after - time()) / 86400 < 30
  annotations:
    summary: "Cert expiring for {{ $labels.domain }}"

Slack integration dla alertów.

2.3 Procedury i Dokumentacja

• Playbook dla odnowień
• Contact list
• Escalation procedures
• Runbooks

Wyniki po 1 miesiącu:

• 0 wygasłych certyfikatów
• Wszystkie zespoły otrzymują alerty
• Standardowe procedury w Confluence

Etap 3: Pełna Automatyzacja (3 miesiące)

Cel: Zero-touch certificate management

3.1 Kubernetes (70% infrastruktury)

Wdrożenie cert-manager:

# Installation
helm install cert-manager jetstack/cert-manager \
  --namespace cert-manager \
  --create-namespace \
  --version v1.13.0

# ClusterIssuer
kubectl apply -f - <<YAML
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: ssl-team@company.com
    privateKeySecretRef:
      name: letsencrypt-prod
    solvers:
    - dns01:
        route53:
          region: us-east-1
YAML

Migration wszystkich Ingress (skrypt):

#!/usr/bin/env python3
import subprocess
import json

# Get all ingresses
result = subprocess.run(['kubectl', 'get', 'ingress', '-A', '-o', 'json'], 
                       capture_output=True, text=True)
ingresses = json.loads(result.stdout)

for ing in ingresses['items']:
    namespace = ing['metadata']['namespace']
    name = ing['metadata']['name']
    
    # Add cert-manager annotation
    subprocess.run([
        'kubectl', 'annotate', 'ingress', name, '-n', namespace,
        'cert-manager.io/cluster-issuer=letsencrypt-prod',
        '--overwrite'
    ])
    
    print(f"✓ Migrated {namespace}/{name}")

3.2 Load Balancers (AWS/Azure/GCP)

AWS ALB z ACM:

# Automatyczne request i attach certificates
aws acm request-certificate \
  --domain-name example.com \
  --validation-method DNS \
  --subject-alternative-names "*.example.com"

# Auto-renewal przez AWS

3.3 Legacy VMs

Ansible playbook dla automatyzacji:

# renew-certificates.yml
---
- hosts: web_servers
  tasks:
    - name: Install certbot
      apt:
        name: certbot
        state: present
    
    - name: Renew certificates
      command: certbot renew --quiet
      register: renewal
    
    - name: Reload nginx if cert renewed
      service:
        name: nginx
        state: reloaded
      when: renewal.changed
    
    - name: Setup cron job
      cron:
        name: "Certbot renewal"
        minute: "0"
        hour: "3"
        job: "certbot renew --quiet && systemctl reload nginx"

3.4 CI/CD Integration

GitOps workflow:

# .github/workflows/certificate-check.yml
name: Certificate Check

on:
  schedule:
    - cron: '0 0 * * *'  # Daily
  push:
    paths:
      - 'infrastructure/**'

jobs:
  check-certificates:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Check certificates
        run: |
          ./scripts/check-all-certs.sh
      
      - name: Create issue if expiring soon
        if: failure()
        uses: actions/github-script@v6
        with:
          script: |
            github.rest.issues.create({
              owner: context.repo.owner,
              repo: context.repo.repo,
              title: 'SSL Certificates Expiring Soon',
              body: 'Check the workflow run for details.'
            })

Kubernetes i cert-manager to jeden z filarów tej architektury. Jeśli chcesz zrozumieć jak to działa od środka, sprawdź nasz szczegółowy przewodnik po automatyzacji certyfikatów SSL w Kubernetes.

Wyniki Po 6 Miesiącach

Metryki Techniczne

Metryki Biznesowe

Oszczędności:

• Koszty certyfikatów: -$15,300/rok
• Czas zespołu (40h → 2h): $6,080/miesiąc (avg $160/h * 38h)
• Total savings: $88,260/rok

Unikn­ięte straty:

• 0 przestojów vs 2h/rok = $47,000+ zaoszczędzone

Jakość:

• 100% uptime SSL/TLS
• 0 customer complaints o certyfikatach
• Lepsza pozycja SEO (no cert errors)

Team Feedback

DevOps Team:

“Przestaliśmy się martwić o certyfikaty. Wszystko działa samo.”

Security Team:

“Wreszcie mamy pełną widoczność. Wiemy dokładnie co się dzieje.”

Business:

“Brak incydentów SSL to ogromna zmiana. Klienci są szczęśliwsi.”

Lekcje Wyciągnięte

Co Zadziałało

1. Inwentaryzacja najpierw - nie można zautomatyzować tego czego nie znasz
2. Quick wins - monitoring dał natychmiastowy ROI
3. Etapowe wdrażanie - K8s → Cloud LB → Legacy VMs
4. GitOps mindset - infrastructure as code dla cert
5. Monitoring 24/7 - własny + zewnętrzny (CrtMgr)

Co By Zrobili Inaczej

1. Wcześniej zacząć - koszt opóźnienia był wysoki
2. Więcej testów na staging - kilka edge cases w prod
3. Lepsza dokumentacja - onboarding nowych członków zespołu
4. Wcześniejsza komunikacja - niektóre zespoły zaskoczone zmianami

Wskazówki dla Innych

Do’s:

• ✓ Zacznij od inwentaryzacji
• ✓ Użyj Let’s Encrypt gdzie możesz
• ✓ Automatyzuj monitoring przed automatyzacją odnowień
• ✓ Testuj na staging
• ✓ Dokumentuj wszystko
• ✓ Komunikuj się z zespołami

Don’ts:

• ✗ Nie migruj wszystkiego naraz
• ✗ Nie zapomnij o monitoring
• ✗ Nie ignoruj legacy apps
• ✗ Nie zapomnij o backup procedures
• ✗ Nie pomijaj testów

Tech Stack - Finalna Architektura

┌─────────────────────────────────────┐
│         Applications                 │
│   K8s   │  Cloud  │   Legacy VMs   │
└─────────┴─────────┴────────────────┘
     │         │            │
     ▼         ▼            ▼
┌─────────────────────────────────────┐
│      Certificate Management         │
│  cert-manager │  ACM  │  certbot   │
└─────────────────────────────────────┘
     │         │            │
     ▼         ▼            ▼
┌─────────────────────────────────────┐
│         Let's Encrypt               │
└─────────────────────────────────────┘
     │
     ▼
┌─────────────────────────────────────┐
│    Monitoring & Alerting            │
│  Prometheus │ Grafana │ CrtMgr     │
└─────────────────────────────────────┘
     │
     ▼
┌─────────────────────────────────────┐
│      Alerting Channels              │
│   Slack  │  Email  │  PagerDuty    │
└─────────────────────────────────────┘

Timeline & Budget

Timeline: 4.5 miesiące

• Miesiąc 1: Inwentaryzacja + Quick wins
• Miesiąc 2-4: Automatyzacja K8s, Cloud, VMs
• Miesiąc 4.5: Testing, dokumentacja, training

Budget: $12,000

• Tools/licenses: $2,000
• DevOps time (3 eng * 1.5 months): $10,000
• ROI: 2 miesiące (dzięki oszczędnościom)

Automatyzacja certyfikatów to nie projekt na rok - to zmiana sposobu myślenia o infrastrukturze. Zamiast gasić pożary, zacznij im zapobiegać. Jeśli planujesz podobną transformację, zacznij od inwentaryzacji - CrtMgr pomoże ci błyskawicznie zobaczyć co masz, ustaw monitoring i alerty, a dopiero potem bierz się za automatyzację odnowień. Powodzenia - wyniki mówią same za siebie.