Wzorce wdrażania

Wzorce wdrażania

Opanuj automatyzację wdrażania z Claude Code. Od generowania konfiguracji wdrażania po orkiestrację złożonych procesów wydania, ten przewodnik obejmuje praktyczne wzorce dla nowoczesnych przepływów wdrażania.

Przegląd automatyzacji wdrażania

Notatka

Claude Code może generować konfiguracje wdrażania, tworzyć procedury wycofywania i pomagać w orkiestracji złożonych wdrożeń wielośrodowiskowych z zachowaniem spójności i niezawodności.

Kluczowe obszary wdrażania

Generowanie konfiguracji

• Infrastruktura jako kod
• Orkiestracja kontenerów
• Potoki CI/CD
• Konfiguracje środowisk

Zarządzanie wydaniami

• Strategie wdrażania
• Procedury wycofywania
• Kontrole zdrowia
• Skrypty migracji

Konfiguracja monitorowania

• Konfiguracje observability
• Definicje alertów
• Tworzenie dashboardów
• Agregacja logów

Infrastruktura jako kod

Generowanie Terraform

1. Wygeneruj podstawową infrastrukturę

   claude "Utwórz konfigurację Terraform dla:
   - AWS VPC z publicznymi/prywatnymi podsieciami
   - Klaster EKS z 3 grupami węzłów
   - PostgreSQL RDS z replikami odczytu
   - Klaster ElastiCache Redis
   - Application Load Balancer
   Przestrzegaj AWS Well-Architected Framework" \
   --output infrastructure/terraform/

2. Utwórz warianty środowisk

   # Środowisko developerskie
   claude "Utwórz Terraform tfvars dla developmentu:
   - Mniejsze rozmiary instancji
   - Wdrożenie w jednej AZ
   - Minimalna redundancja
   - Skupienie na optymalizacji kosztów" \
   --output infrastructure/terraform/environments/dev.tfvars
   
   # Środowisko produkcyjne
   claude "Utwórz Terraform tfvars dla produkcji:
   - Wysoka dostępność w 3 AZ
   - Konfiguracje auto-skalowania
   - Ulepszone monitorowanie
   - Strategie kopii zapasowych" \
   --output infrastructure/terraform/environments/prod.tfvars

3. Wygeneruj moduły

   claude "Utwórz moduły Terraform wielokrotnego użytku dla:
   - Standardowej konfiguracji aplikacji webowej
   - Provisjoningu bazy danych z kopiami zapasowymi
   - Klastra kontenerów z monitorowaniem
   - Networkingu z grupami bezpieczeństwa
   Dołącz przykłady i dokumentację" \
   --output infrastructure/terraform/modules/

Szablony CloudFormation

Stos aplikacji

claude "Wygeneruj szablon CloudFormation dla:
- Aplikacji Elastic Beanstalk
- Konfiguracji auto-skalowania
- Dystrybucji CloudFront
- Bucketów S3 dla zasobów statycznych
- Konfiguracji DNS Route53
Dołącz parametry do dostosowywania środowiska" \
--output cloudformation/app-stack.yaml

Stos serverless

claude "Utwórz CloudFormation dla aplikacji serverless:
- Funkcje Lambda z warstwami
- API Gateway z domeną niestandardową
- Tabele DynamoDB ze strumieniami
- Step Functions dla przepływów
- EventBridge dla routingu zdarzeń" \
--output cloudformation/serverless-stack.yaml

Stos kontenerów

claude "Wygeneruj CloudFormation dla kontenerów:
- Klaster ECS Fargate
- Definicje zadań z sekretami
- Application Load Balancer
- Auto-skalowanie serwisów
- CloudWatch Container Insights" \
--output cloudformation/container-stack.yaml

Wdrożenia Kubernetes

Generowanie manifestów

Kompletna aplikacja K8s

# Wygeneruj kompleksowe manifesty Kubernetes
claude "Utwórz manifesty Kubernetes dla aplikacji mikrousług:

Serwisy:
- API Gateway (nginx ingress)
- Serwis Auth (Node.js)
- Serwis User (Python)
- Serwis Payment (Go)
- Frontend (React)

Dołącz:
- Wdrożenia z limitami zasobów
- Serwisy do komunikacji wewnętrznej
- ConfigMaps dla konfiguracji
- Secrets dla wrażliwych danych
- Reguły Ingress z TLS
- HorizontalPodAutoscaler
- PodDisruptionBudgets
- NetworkPolicies dla bezpieczeństwa
- ServiceMonitor dla Prometheus

Użyj najlepszych praktyk dla produkcji" \
--output k8s/manifests/

Tworzenie chartów Helm

1. Zainicjuj chart Helm

   claude "Utwórz chart Helm dla aplikacji mikrousług:
   - Chart.yaml z właściwymi metadanymi
   - Elastyczny values.yaml ze środowiskami
   - Szablony dla wszystkich zasobów
   - Helpery dla wspólnych wzorców
   - NOTES.txt z instrukcjami użycia
   - README.md z przykładami" \
   --output helm/microservices-app/

2. Wartości specyficzne dla środowisk

   # Wartości developerskie
   claude "Utwórz wartości Helm dla developmentu:
   - Pojedyncze repliki
   - Minimalne zasoby
   - Lokalne przechowywanie
   - Logowanie debug
   - Bez TLS" \
   --output helm/microservices-app/values-dev.yaml
   
   # Wartości stagingowe
   claude "Utwórz wartości Helm dla stagingu:
   - 2 repliki
   - Umiarkowane zasoby
   - Trwałe przechowywanie
   - Logowanie info
   - TLS Let's Encrypt" \
   --output helm/microservices-app/values-staging.yaml
   
   # Wartości produkcyjne
   claude "Utwórz wartości Helm dla produkcji:
   - 3+ repliki z pod anti-affinity
   - Zasoby klasy produkcyjnej
   - Przechowywanie Multi-AZ
   - Logowanie strukturalne
   - Komercyjne certyfikaty TLS" \
   --output helm/microservices-app/values-prod.yaml

Konfiguracja Kustomize

Konfiguracja bazowa

claude "Utwórz bazową konfigurację Kustomize:
- Podstawowe manifesty dla wszystkich zasobów
- Wspólne etykiety i adnotacje
- Współdzielone ConfigMaps
- Polityki przekrojowe" \
--output k8s/kustomize/base/

Nakładki środowisk

claude "Utwórz nakładki Kustomize dla:
- Development (lokalny)
- Staging (AWS)
- Production (AWS)
- Strona DR (Azure)
Każda ze specyficznymi łatami i transformacjami" \
--output k8s/kustomize/overlays/

Generowanie potoków CI/CD

Przepływy GitHub Actions

Kompletny potok CI/CD

# Wygenerowany przez Claude Code
name: Deploy to Production

on:
  push:
    tags:
      - 'v*'

env:
  AWS_REGION: us-east-1
  ECR_REPOSITORY: myapp
  EKS_CLUSTER: production-cluster

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

      - name: Run Tests
        run: |
          npm ci
          npm test
          npm run test:integration

      - name: Security Scan
        run: |
          npm audit
          docker run --rm -v "$PWD":/src \
            aquasec/trivy fs --severity HIGH,CRITICAL /src

  build:
    needs: test
    runs-on: ubuntu-latest
    outputs:
      image-tag: ${{ steps.meta.outputs.tags }}

    steps:
      - uses: actions/checkout@v4

      - name: Configure AWS
        uses: aws-actions/configure-aws-credentials@v4
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: ${{ env.AWS_REGION }}

      - name: Login to ECR
        id: login-ecr
        uses: aws-actions/amazon-ecr-login@v2

      - name: Build and Push
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ steps.login-ecr.outputs.registry }}/${{ env.ECR_REPOSITORY }}
          tags: |
            type=semver,pattern={{version}}
            type=semver,pattern={{major}}.{{minor}}
            type=sha

      - name: Build Docker image
        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

  deploy:
    needs: build
    runs-on: ubuntu-latest
    environment: production

    steps:
      - uses: actions/checkout@v4

      - name: Configure kubectl
        run: |
          aws eks update-kubeconfig \
            --region ${{ env.AWS_REGION }} \
            --name ${{ env.EKS_CLUSTER }}

      - name: Deploy with Helm
        run: |
          helm upgrade --install myapp ./helm/myapp \
            --namespace production \
            --create-namespace \
            --values helm/myapp/values-prod.yaml \
            --set image.tag=${{ needs.build.outputs.image-tag }} \
            --wait \
            --timeout 10m

      - name: Verify Deployment
        run: |
          kubectl rollout status deployment/myapp -n production
          kubectl get pods -n production

      - name: Run Smoke Tests
        run: |
          npm run test:smoke -- --env=production

Potok GitLab CI

Budowanie Docker

.gitlab-ci.yml

stages:
  - test
  - build
  - deploy

variables:
  DOCKER_DRIVER: overlay2
  DOCKER_TLS_CERTDIR: "/certs"

test:
  stage: test
  image: node:18
  script:
    - npm ci
    - npm test
    - npm run lint
  coverage: '/Coverage: \d+\.\d+%/'

build:
  stage: build
  image: docker:latest
  services:
    - docker:dind
  before_script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
  script:
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
    - docker tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA $CI_REGISTRY_IMAGE:latest
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
    - docker push $CI_REGISTRY_IMAGE:latest

deploy-staging:
  stage: deploy
  image: bitnami/kubectl:latest
  script:
    - kubectl config use-context $K8S_CONTEXT_STAGING
    - kubectl set image deployment/myapp myapp=$CI_REGISTRY_IMAGE:$CI_COMMIT_SHA -n staging
    - kubectl rollout status deployment/myapp -n staging
  environment:
    name: staging
    url: https://staging.example.com
  only:
    - develop

deploy-production:
  stage: deploy
  image: bitnami/kubectl:latest
  script:
    - kubectl config use-context $K8S_CONTEXT_PRODUCTION
    - kubectl set image deployment/myapp myapp=$CI_REGISTRY_IMAGE:$CI_COMMIT_SHA -n production
    - kubectl rollout status deployment/myapp -n production
  environment:
    name: production
    url: https://example.com
  only:
    - tags
  when: manual

Wdrażanie Terraform

# Wdrażanie infrastruktury
terraform-plan:
  stage: plan
  image: hashicorp/terraform:latest
  script:
    - cd infrastructure/terraform
    - terraform init
    - terraform plan -out=tfplan
  artifacts:
    paths:
      - infrastructure/terraform/tfplan

terraform-apply:
  stage: deploy
  image: hashicorp/terraform:latest
  script:
    - cd infrastructure/terraform
    - terraform init
    - terraform apply tfplan
  dependencies:
    - terraform-plan
  when: manual
  only:
    - main

Strategie wdrażania

Wdrożenie blue-green

1. Wygeneruj skrypty blue-green

   claude "Utwórz skrypty wdrożenia blue-green:
   - Weryfikację kontroli zdrowia
   - Logikę przełączania ruchu
   - Procedury wycofywania
   - Obsługę migracji bazy danych
   Dla Kubernetes i AWS ECS" \
   --output deployment/blue-green/

2. Zarządzanie ruchem

   claude "Wygeneruj konfigurację przełączania ruchu:
   - Przełączanie grup docelowych AWS ALB
   - Aktualizacje selektorów serwisów Kubernetes
   - VirtualService Istio dla canary
   - Reguły load balancera CloudFlare" \
   --output deployment/traffic-management/

Wdrożenie canary

Stopniowe wdrażanie

# Wygeneruj konfigurację Flagger dla wdrożeń canary
claude "Utwórz konfigurację wdrożenia canary Flagger:
- Stopniowe przesuwanie ruchu (10%, 25%, 50%, 100%)
- Automatyczne wycofanie przy niepowodzeniach
- Niestandardowe metryki dla KPI biznesowych
- Powiadomienia Slack
- Testowanie obciążenia podczas canary
Dołącz dla Istio i AWS App Mesh" \
--output deployment/canary/flagger-config.yaml

# Wygeneruj niestandardowe metryki
claude "Utwórz zapytania Prometheus dla analizy canary:
- Wskaźnik sukcesu żądań
- Latencja P95
- Wskaźnik błędów według kodu statusu
- Metryki biznesowe (zamówienia, rejestracje)
Formatuj dla MetricTemplate Flagger" \
--output deployment/canary/metrics.yaml

Migracje baz danych

Strategie migracji

Migracje bez przestojów

claude "Utwórz plan migracji bez przestojów:
- Zmiany schematu kompatybilne wstecz
- Skrypty migracji danych
- Procedury wycofywania
- Zapytania weryfikacyjne
Dla PostgreSQL z milionami rekordów" \
--output migrations/zero-downtime/

Obsługa wielu wersji

claude "Wygeneruj strategię migracji dla:
- Obsługi starego i nowego schematu
- Flag funkcji dla stopniowego wdrażania
- Synchronizacji danych między wersjami
- Procedur czyszczenia
Dołącz przykładowy kod" \
--output migrations/multi-version/

Monitorowanie i wycofywanie

Monitorowanie wdrożenia

1. Utwórz stos monitorowania

   claude "Wygeneruj konfigurację monitorowania:
   - Konfiguracje scrape Prometheus
   - Dashboardy Grafana dla wdrożeń
   - Reguły alertów dla niepowodzeń
   - Zbieranie niestandardowych metryk
   - Zapytania agregacji logów" \
   --output monitoring/deployment/

2. Automatyczne wycofywanie

   claude "Utwórz system automatycznego wycofywania:
   - Definicje kontroli zdrowia
   - Logikę wykrywania niepowodzeń
   - Wyzwalacze wycofywania
   - Zachowanie stanu
   - System powiadomień
   Obsługa Kubernetes, ECS i Lambda" \
   --output deployment/rollback/

Kontrole zdrowia

Kompleksowe kontrole zdrowia

# Wygenerowany system kontroli zdrowia
import asyncio
import aiohttp
from typing import List, Dict
import json

class HealthChecker:
    def __init__(self, config_file: str):
        with open(config_file) as f:
            self.config = json.load(f)
        self.results = {}

    async def check_endpoint(self, endpoint: Dict) -> Dict:
        """Sprawdź zdrowotność indywidualnego endpointu"""
        try:
            async with aiohttp.ClientSession() as session:
                async with session.get(
                    endpoint['url'],
                    timeout=aiohttp.ClientTimeout(total=endpoint.get('timeout', 30))
                ) as response:

                    # Podstawowe zdrowotność
                    health = {
                        'url': endpoint['url'],
                        'status_code': response.status,
                        'response_time': response.headers.get('X-Response-Time'),
                        'healthy': response.status == endpoint.get('expected_status', 200)
                    }

                    # Niestandardowe sprawdzenia
                    if 'expected_response' in endpoint:
                        body = await response.json()
                        health['matches_expected'] = (
                            body == endpoint['expected_response']
                        )

                    return health

        except Exception as e:
            return {
                'url': endpoint['url'],
                'healthy': False,
                'error': str(e)
            }

    async def check_all(self) -> Dict:
        """Uruchom wszystkie kontrole zdrowia równolegle"""
        tasks = [
            self.check_endpoint(endpoint)
            for endpoint in self.config['endpoints']
        ]

        results = await asyncio.gather(*tasks)

        # Zagreguj wyniki
        return {
            'timestamp': datetime.now().isoformat(),
            'overall_health': all(r['healthy'] for r in results),
            'endpoints': results,
            'summary': {
                'total': len(results),
                'healthy': sum(1 for r in results if r['healthy']),
                'unhealthy': sum(1 for r in results if not r['healthy'])
            }
        }

    async def continuous_monitoring(self, interval: int = 60):
        """Ciągle monitoruj zdrowotność"""
        while True:
            results = await self.check_all()

            # Przechowaj wyniki
            self.results[results['timestamp']] = results

            # Alertuj jeśli niezdrowe
            if not results['overall_health']:
                await self.send_alert(results)

            await asyncio.sleep(interval)

    async def send_alert(self, results: Dict):
        """Wyślij alerty dla niepowodzeń"""
        # Implementuj alerty Slack, PagerDuty, email
        pass

# Plik konfiguracyjny
health_config = {
    "endpoints": [
        {
            "name": "API Gateway",
            "url": "https://api.example.com/health",
            "expected_status": 200,
            "timeout": 30
        },
        {
            "name": "Serwis Auth",
            "url": "https://auth.example.com/health",
            "expected_status": 200,
            "expected_response": {"status": "healthy"}
        },
        {
            "name": "Baza danych",
            "url": "https://api.example.com/health/db",
            "expected_status": 200,
            "critical": true
        }
    ],
    "alerts": {
        "slack_webhook": "https://hooks.slack.com/...",
        "pagerduty_key": "..."
    }
}

Zarządzanie środowiskami

Generowanie konfiguracji

ConfigMaps Kubernetes

# Wygeneruj konfiguracje środowisk
for env in dev staging prod; do
  claude "Utwórz ConfigMap dla środowiska $env:
  - Endpointy API
  - Flagi funkcji
  - Ustawienia cache
  - Poziomy logowania
  - URL serwisów zewnętrznych
  Użyj zmiennych szablonowych dla sekretów" \
  --output k8s/configs/configmap-$env.yaml
done

AWS Parameter Store

claude "Wygeneruj parametry AWS Systems Manager:
- Strukturę hierarchiczną (/app/env/component/key)
- SecureString dla wartości wrażliwych
- Standard tier dla konfiguracji
- Szablon CloudFormation
- Konfigurację Terraform
Dołącz polityki dostępu" \
--output infrastructure/parameter-store/

Pliki .env

claude "Utwórz szablony plików środowiskowych:
- .env.example ze wszystkimi zmiennymi
- .env.development z wartościami lokalnymi
- .env.test dla testowania
- Dokumentację dla każdej zmiennej
- Skrypt walidacji
Nigdy nie dołączaj prawdziwych sekretów" \
--output environments/

Skrypty automatyzacji wdrożenia

Skrypty orkiestracji

Główny skrypt wdrożenia

#!/bin/bash
# deploy.sh - Wygenerowany przez Claude Code

set -euo pipefail

# Konfiguracja
ENVIRONMENT="${1:-staging}"
VERSION="${2:-latest}"
DRY_RUN="${DRY_RUN:-false}"

# Kolory dla wyjścia
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'

log() {
    echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
}

error() {
    echo -e "${RED}[ERROR]${NC} $1" >&2
    exit 1
}

warn() {
    echo -e "${YELLOW}[WARN]${NC} $1"
}

# Sprawdzenia przed wdrożeniem
pre_deploy_checks() {
    log "Uruchamianie sprawdzeń przed wdrożeniem..."

    # Sprawdź łączność z klastrem
    if ! kubectl cluster-info &>/dev/null; then
        error "Nie można połączyć się z klastrem Kubernetes"
    fi

    # Zweryfikuj czy namespace istnieje
    if ! kubectl get namespace "$ENVIRONMENT" &>/dev/null; then
        warn "Namespace $ENVIRONMENT nie istnieje, tworzę..."
        kubectl create namespace "$ENVIRONMENT"
    fi

    # Sprawdź czy obraz istnieje
    if ! docker manifest inspect "$IMAGE:$VERSION" &>/dev/null; then
        error "Obraz Docker $IMAGE:$VERSION nie został znaleziony"
    fi

    # Uruchom skan bezpieczeństwa
    log "Uruchamianie skanu bezpieczeństwa..."
    trivy image "$IMAGE:$VERSION" --severity HIGH,CRITICAL

    log "Sprawdzenia przed wdrożeniem przeszły ✓"
}

# Wdróż aplikację
deploy() {
    log "Wdrażanie wersji $VERSION do $ENVIRONMENT..."

    if [[ "$DRY_RUN" == "true" ]]; then
        log "DRY RUN - zostałoby wykonane:"
        echo "helm upgrade --install myapp ./helm/myapp \\"
        echo "  --namespace $ENVIRONMENT \\"
        echo "  --values helm/myapp/values-$ENVIRONMENT.yaml \\"
        echo "  --set image.tag=$VERSION"
        return 0
    fi

    # Kopia zapasowa aktualnego stanu
    kubectl get all -n "$ENVIRONMENT" -o yaml > "backup-$ENVIRONMENT-$(date +%s).yaml"

    # Wdróż z Helm
    helm upgrade --install myapp ./helm/myapp \
        --namespace "$ENVIRONMENT" \
        --values "helm/myapp/values-$ENVIRONMENT.yaml" \
        --set image.tag="$VERSION" \
        --wait \
        --timeout 10m \
        --atomic

    log "Wdrożenie ukończone ✓"
}

# Weryfikacja po wdrożeniu
verify_deployment() {
    log "Weryfikacja wdrożenia..."

    # Czekaj na rollout
    kubectl rollout status deployment/myapp -n "$ENVIRONMENT"

    # Sprawdź status podów
    READY_PODS=$(kubectl get pods -n "$ENVIRONMENT" -l app=myapp \
        -o jsonpath='{.items[?(@.status.phase=="Running")].metadata.name}' | wc -w)

    if [[ "$READY_PODS" -lt 1 ]]; then
        error "Nie znaleziono uruchomionych podów"
    fi

    # Uruchom kontrole zdrowia
    log "Uruchamianie kontroli zdrowia..."
    ./scripts/health-check.sh "$ENVIRONMENT"

    # Uruchom testy smoke
    log "Uruchamianie testów smoke..."
    npm run test:smoke -- --env="$ENVIRONMENT"

    log "Weryfikacja ukończona ✓"
}

# Główne wykonanie
main() {
    log "Rozpoczynanie procesu wdrożenia"
    log "Środowisko: $ENVIRONMENT"
    log "Wersja: $VERSION"

    pre_deploy_checks
    deploy
    verify_deployment

    log "Wdrożenie udane! 🚀"
}

# Uruchom główną funkcję
main "$@"

Najlepsze praktyki

Najlepsze praktyki wdrażania

1. Automatyzuj wszystko - Kroki ręczne prowadzą do błędów
2. Testuj na stagingu - Zawsze waliduj przed produkcją
3. Monitoruj aktywnie - Dowiedz się natychmiast gdy coś się psuje
4. Planuj wycofania - Miej szybki sposób na cofnięcie
5. Dokumentuj procesy - Utrzymuj aktualne runbooki
6. Używaj GitOps - Git jako jedyne źródło prawdy
7. Implementuj stopniowe wdrażania - Zmniejsz obszar wpływu

Względy bezpieczeństwa

Uwaga

• Nigdy nie commituj sekretów do repozytoriów
• Używaj właściwego zarządzania sekretami (Vault, AWS Secrets Manager)
• Implementuj dostęp z najniższymi uprawnieniami
• Regularnie audituj uprawnienia wdrożenia
• Szyfruj wrażliwe dane w tranzycie i spoczynku

Rozwiązywanie problemów z wdrożeniami

Częste problemy

Nieudane kontrole zdrowia

claude "Utwórz przewodnik rozwiązywania problemów dla:
- Analizy niepowodzeń kontroli zdrowia
- Częstych przyczyn i poprawek
- Poleceń debugowania
- Lokalizacji logów
Formatuj jako runbook" \
--output docs/troubleshooting/health-checks.md

Ograniczenia zasobów

claude "Wygeneruj skrypty debugowania zasobów:
- Sprawdź pojemność klastra
- Zidentyfikuj wąskie gardła zasobów
- Zaleć rozwiązania skalowania
- Wskazówki optymalizacji kosztów" \
--output scripts/debug-resources.sh

Następne kroki

Kontynuuj ulepszanie swoich przepływów wdrażania:

• Integracja GitHub Actions dla CI/CD
• Konteneryzacja dla przepływów Docker
• Koordynacja IDE dla integracji rozwoju

Pamiętaj: Dobre praktyki wdrażania to niezawodność, powtarzalność i szybkie odzyskiwanie. Używaj Claude Code do generowania solidnych konfiguracji wdrażania, które obsługują przypadki graniczne i niepowodzenia z gracją.