DevOps i infrastruktura jako kod z AI

Nowoczesny DevOps wymaga zarządzania złożoną infrastrukturą, pipeline’ami CI/CD, systemami monitoringu i strategiami wdrożeń. Ta lekcja pokazuje, jak możliwości AI w Cursor przekształcają przepływy pracy DevOps, czyniąc infrastrukturę jako kod (IaC) bardziej dostępną i niezawodną.

Rewolucja DevOps wspomagana AI

Tradycyjny DevOps wymaga głębokiej wiedzy o wielu narzędziach, platformach i najlepszych praktykach. Wsparcie AI demokratyzuje tę ekspertyzę, pomagając programistom pisać kod infrastruktury, tworzyć pipeline’y wdrożeń i implementować monitoring z pewnością siebie.

Wyzwania DevOps, które AI rozwiązuje

Złożoność infrastruktury

AI generuje IaC niezależny od chmury z wbudowanymi najlepszymi praktykami

Automatyzacja pipeline'ów

AI tworzy zaawansowane pipeline’y CI/CD dostosowane do twojego stacku

Konfiguracja bezpieczeństwa

AI implementuje najlepsze praktyki bezpieczeństwa i wymagania zgodności

Optymalizacja kosztów

AI sugeruje ekonomiczne konfiguracje infrastruktury

Infrastruktura jako kod (IaC)

Rozpoczynanie z Terraform

Konfiguracja struktury projektu

# Poproś AI o stworzenie struktury projektu Terraform
"Stwórz strukturę projektu Terraform dla:
- Konfiguracji wielośrodowiskowej (dev, staging, prod)
- Infrastruktury AWS
- Projektowania modularnego z komponentami wielokrotnego użytku
- Zdalnego zarządzania stanem
- Najlepszych praktyk zarządzania zmiennymi"

Generowanie podstawowej infrastruktury

# AI tworzy główną infrastrukturę
"Generuj konfigurację Terraform dla:
- VPC z publicznymi/prywatnymi podsieciami
- Klastra EKS z grupami węzłów
- PostgreSQL RDS z replikami odczytu
- Klastra Redis dla cachowania
- Bucketów S3 z odpowiednim szyfrowaniem
- Ról i polityk IAM"

Konfiguracja środowiska

# AI implementuje konfiguracje specyficzne dla środowiska
"Stwórz konfiguracje specyficzne dla środowiska:
- Development: minimalne zasoby, zoptymalizowane pod kątem kosztów
- Staging: podobne do produkcji ale mniejsze
- Production: wysoka dostępność, auto-skalowanie
Zawrzyj odpowiednią strategię tagowania"

Implementacje platform chmurowych

# AI generuje infrastrukturę AWS
"Stwórz infrastrukturę AWS dla aplikacji webowej:
- Application Load Balancer z WAF
- ECS Fargate dla usług konteneryzowanych
- Aurora Serverless dla bazy danych
- CloudFront CDN dla statycznych zasobów
- Secrets Manager dla poświadczeń
- Monitoring i alarmy CloudWatch"

# AI zapewnia kompletną implementację
module "web_app" {
  source = "./modules/web-application"

  environment = var.environment
  region      = var.aws_region

  vpc_config = {
    cidr_block           = var.vpc_cidr
    availability_zones   = data.aws_availability_zones.available.names
    enable_nat_gateway   = var.environment == "production"
    single_nat_gateway   = var.environment != "production"
  }

  ecs_config = {
    task_cpu    = var.task_cpu
    task_memory = var.task_memory
    desired_count = var.environment == "production" ? 3 : 1

    autoscaling = {
      min_capacity = var.environment == "production" ? 3 : 1
      max_capacity = var.environment == "production" ? 10 : 3

      target_cpu_utilization    = 70
      target_memory_utilization = 80
    }
  }

  # ... kompletna konfiguracja
}

# AI tworzy infrastrukturę Azure
"Skonfiguruj infrastrukturę Azure dla mikroserwisów:
- Klaster AKS z wieloma pulami węzłów
- Azure Database for PostgreSQL
- Application Gateway z WAF
- Key Vault dla sekretów
- Container Registry
- Monitor i Log Analytics"

# AI implementuje wzorce specyficzne dla Azure
resource "azurerm_kubernetes_cluster" "main" {
  name                = "${var.project_name}-aks-${var.environment}"
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name
  dns_prefix          = "${var.project_name}-${var.environment}"

  default_node_pool {
    name                = "system"
    node_count          = var.system_node_count
    vm_size            = "Standard_D2_v3"
    availability_zones  = ["1", "2", "3"]
    enable_auto_scaling = true
    min_count          = 1
    max_count          = 3
  }

  identity {
    type = "SystemAssigned"
  }

  network_profile {
    network_plugin    = "azure"
    network_policy    = "calico"
    load_balancer_sku = "standard"
  }

  # ... dodatkowa konfiguracja
}

# AI implementuje infrastrukturę GCP
"Stwórz infrastrukturę GCP dla pipeline'u danych:
- Klaster GKE Autopilot
- Cloud SQL z wysoką dostępnością
- Pub/Sub dla messagingu
- Dataflow dla przetwarzania strumieni
- BigQuery dla analityki
- Cloud Storage dla data lake"

# AI zapewnia konfigurację zoptymalizowaną dla GCP
module "data_platform" {
  source = "./modules/gcp-data-platform"

  project_id  = var.gcp_project_id
  region      = var.gcp_region
  environment = var.environment

  gke_config = {
    autopilot_enabled = true
    release_channel   = "STABLE"

    workload_identity_config = {
      enabled = true
    }
  }

  bigquery_config = {
    dataset_id = "${var.project_name}_${var.environment}"
    location   = "US"

    tables = {
      events = {
        time_partitioning = {
          type  = "DAY"
          field = "timestamp"
        }
        clustering = ["user_id", "event_type"]
      }
    }
  }

  # ... kompletna implementacja
}

Infrastruktura Kubernetes

# AI pomaga z manifestami Kubernetes
"Stwórz manifesty Kubernetes dla:
- Wdrożenia mikroserwisów z HPA
- Konfiguracji service mesh (Istio)
- Ingress z terminacją TLS
- ConfigMaps i Secrets
- Polityk sieciowych
- Reguł RBAC"

# AI generuje manifesty gotowe do produkcji
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-service
  namespace: production
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api-service
  template:
    metadata:
      labels:
        app: api-service
        version: v1
    spec:
      serviceAccountName: api-service
      containers:
      - name: api
        image: myregistry/api:latest
        ports:
        - containerPort: 8080
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: database-credentials
              key: connection-string
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: api-service-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: api-service
  minReplicas: 3
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

Tworzenie pipeline’ów CI/CD

Workflow’y GitHub Actions

# AI tworzy kompleksowy pipeline CI/CD
"Stwórz workflow GitHub Actions dla:
- Monorepo z wieloma serwisami
- Build'ów Docker z cachowaniem warstw
- Automatycznych testów (unit, integration, e2e)
- Skanowania bezpieczeństwa (SAST, sprawdzanie zależności)
- Wdrożenia wielośrodowiskowego
- Możliwości rollback"

name: Pipeline CI/CD

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  detect-changes:
    runs-on: ubuntu-latest
    outputs:
      services: ${{ steps.detect.outputs.services }}
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0

      - name: Wykryj zmienione serwisy
        id: detect
        run: |
          # AI generuje logikę wykrywania zmian
          CHANGED_SERVICES=$(git diff --name-only ${{ github.event.before }}..${{ github.sha }} | \
            grep -E '^services/' | \
            cut -d'/' -f2 | \
            sort -u | \
            jq -R -s -c 'split("\n")[:-1]')
          echo "services=$CHANGED_SERVICES" >> $GITHUB_OUTPUT

  build-and-test:
    needs: detect-changes
    strategy:
      matrix:
        service: ${{ fromJson(needs.detect-changes.outputs.services) }}
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Skonfiguruj Docker Buildx
        uses: docker/setup-buildx-action@v2

      - name: Zaloguj do Container Registry
        uses: docker/login-action@v2
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Build i test
        run: |
          # AI implementuje zaawansowany proces build
          docker buildx build \
            --target test \
            --load \
            --cache-from type=gha \
            --cache-to type=gha,mode=max \
            -t ${{ matrix.service }}-test \
            ./services/${{ matrix.service }}

          docker run --rm ${{ matrix.service }}-test

      - name: Skanowanie bezpieczeństwa
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: ${{ matrix.service }}-test
          format: 'sarif'
          output: 'trivy-results.sarif'

      - name: Upload wyników skanowania
        uses: github/codeql-action/upload-sarif@v2
        with:
          sarif_file: 'trivy-results.sarif'

  deploy:
    needs: build-and-test
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment: production
    steps:
      # AI implementuje strategię wdrożenia
      - name: Wdróż do Kubernetes
        run: |
          # ... logika wdrożenia

CI/CD wieloplatformowe

# AI tworzy pipeline GitLab CI
"Generuj pipeline GitLab CI z:
- Równoległym wykonywaniem zadań
- Build'ami Docker-in-Docker
- Wdrożeniem Kubernetes
- Review apps dla MR
- Zaplanowanymi skanami bezpieczeństwa"

variables:
  DOCKER_DRIVER: overlay2
  DOCKER_TLS_CERTDIR: "/certs"
  KUBERNETES_MEMORY_REQUEST: 1Gi
  KUBERNETES_MEMORY_LIMIT: 2Gi

stages:
  - build
  - test
  - security
  - deploy
  - cleanup

.build_template:
  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/$SERVICE:$CI_COMMIT_SHA ./services/$SERVICE
    - docker push $CI_REGISTRY_IMAGE/$SERVICE:$CI_COMMIT_SHA

# ... kompletna konfiguracja pipeline'u

// AI tworzy Jenkinsfile
"Stwórz pipeline Jenkins dla:
- Składni declarative pipeline
- Równoległych etapów
- Shared libraries
- Kompatybilności z Blue Ocean
- Powiadomień Slack"

@Library('shared-library') _

pipeline {
    agent {
        kubernetes {
            yaml """
            apiVersion: v1
            kind: Pod
            spec:
              containers:
              - name: docker
                image: docker:dind
                securityContext:
                  privileged: true
              - name: kubectl
                image: bitnami/kubectl:latest
                command: ['cat']
                tty: true
            """
        }
    }

    environment {
        DOCKER_REGISTRY = credentials('docker-registry')
        KUBECONFIG = credentials('kubeconfig')
    }

    stages {
        stage('Build') {
            steps {
                container('docker') {
                    script {
                        // AI implementuje logikę build
                        docker.build("${env.IMAGE_NAME}:${env.BUILD_ID}")
                    }
                }
            }
        }

        // ... dodatkowe etapy
    }

    post {
        success {
            slackSend(color: 'good', message: "Wdrożenie udane: ${env.JOB_NAME} ${env.BUILD_NUMBER}")
        }
        failure {
            slackSend(color: 'danger', message: "Wdrożenie nieudane: ${env.JOB_NAME} ${env.BUILD_NUMBER}")
        }
    }
}

# AI tworzy pipeline Azure DevOps
"Generuj pipeline Azure DevOps z:
- Pipeline'em YAML wieloetapowym
- Ponownym użyciem szablonów
- Bramami zatwierdzenia
- Integracją Azure Key Vault
- Publikowaniem artefaktów"

trigger:
  branches:
    include:
      - main
      - develop
  paths:
    include:
      - services/*

variables:
  - group: production-variables
  - name: buildConfiguration
    value: 'Release'

stages:
- stage: Build
  jobs:
  - job: BuildServices
    strategy:
      matrix:
        service1:
          serviceName: 'api'
        service2:
          serviceName: 'web'
    pool:
      vmImage: 'ubuntu-latest'
    steps:
    - task: Docker@2
      inputs:
        containerRegistry: 'ACR-Connection'
        repository: '$(serviceName)'
        command: 'buildAndPush'
        Dockerfile: 'services/$(serviceName)/Dockerfile'
        tags: |
          $(Build.BuildId)
          latest

- stage: Deploy
  dependsOn: Build
  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
  jobs:
  - deployment: DeployToAKS
    environment: 'production'
    strategy:
      runOnce:
        deploy:
          steps:
          # ... kroki wdrożenia

Orkiestracja kontenerów

Optymalizacja Docker

# AI tworzy zoptymalizowane Dockerfiles
"Stwórz wieloetapowy Dockerfile dla aplikacji Node.js z:
- Minimalnym rozmiarem końcowego obrazu
- Optymalizacją cachowania warstw
- Najlepszymi praktykami bezpieczeństwa
- Użytkownikiem non-root
- Health checks"

# AI generuje zoptymalizowany Dockerfile
# Etap build
FROM node:18-alpine AS builder

# Zainstaluj zależności build
RUN apk add --no-cache python3 make g++

# Ustaw katalog roboczy
WORKDIR /app

# Skopiuj pliki package
COPY package*.json ./
COPY yarn.lock ./

# Zainstaluj zależności z cache mount
RUN --mount=type=cache,target=/root/.yarn \
    yarn install --frozen-lockfile --production=false

# Skopiuj kod źródłowy
COPY . .

# Zbuduj aplikację
RUN yarn build

# Usuń dev dependencies
RUN yarn install --frozen-lockfile --production=true && \
    yarn cache clean

# Etap runtime
FROM node:18-alpine AS runtime

# Zainstaluj zależności runtime
RUN apk add --no-cache tini

# Stwórz użytkownika non-root
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001

# Ustaw katalog roboczy
WORKDIR /app

# Skopiuj zbudowaną aplikację
COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist
COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
COPY --from=builder --chown=nodejs:nodejs /app/package.json ./

# Przełącz na użytkownika non-root
USER nodejs

# Expose port
EXPOSE 3000

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD node healthcheck.js

# Użyj tini dla odpowiedniej obsługi sygnałów
ENTRYPOINT ["/sbin/tini", "--"]

# Uruchom aplikację
CMD ["node", "dist/index.js"]

Tworzenie chartów Helm

# AI tworzy produkcyjne charty Helm
"Generuj chart Helm dla mikroserwisów z:
- Konfigurowalnymi limitami zasobów
- Konfiguracją HPA
- Ingress z TLS
- Integracją service mesh
- Zarządzaniem sekretami
- Integracją monitoringu"

# AI zapewnia kompletną strukturę chartu
# values.yaml
global:
  environment: production
  domain: example.com

services:
  api:
    enabled: true
    replicaCount: 3
    image:
      repository: myregistry/api
      tag: latest
      pullPolicy: IfNotPresent

    resources:
      requests:
        memory: "256Mi"
        cpu: "250m"
      limits:
        memory: "512Mi"
        cpu: "500m"

    autoscaling:
      enabled: true
      minReplicas: 3
      maxReplicas: 10
      targetCPUUtilizationPercentage: 70
      targetMemoryUtilizationPercentage: 80

    service:
      type: ClusterIP
      port: 80
      targetPort: 8080

    ingress:
      enabled: true
      className: nginx
      annotations:
        cert-manager.io/cluster-issuer: letsencrypt-prod
      hosts:
        - host: api.example.com
          paths:
            - path: /
              pathType: Prefix
      tls:
        - secretName: api-tls
          hosts:
            - api.example.com

# templates/deployment.yaml
{{- range $name, $service := .Values.services }}
{{- if $service.enabled }}
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ $name }}
  labels:
    {{- include "microservices.labels" $ | nindent 4 }}
    app.kubernetes.io/component: {{ $name }}
spec:
  {{- if not $service.autoscaling.enabled }}
  replicas: {{ $service.replicaCount }}
  {{- end }}
  selector:
    matchLabels:
      {{- include "microservices.selectorLabels" $ | nindent 6 }}
      app.kubernetes.io/component: {{ $name }}
  template:
    metadata:
      annotations:
        checksum/config: {{ include (print $.Template.BasePath "/configmap.yaml") $ | sha256sum }}
      labels:
        {{- include "microservices.selectorLabels" $ | nindent 8 }}
        app.kubernetes.io/component: {{ $name }}
    spec:
      {{- with $.Values.imagePullSecrets }}
      imagePullSecrets:
        {{- toYaml . | nindent 8 }}
      {{- end }}
      serviceAccountName: {{ include "microservices.serviceAccountName" $ }}
      containers:
        - name: {{ $name }}
          image: "{{ $service.image.repository }}:{{ $service.image.tag | default $.Chart.AppVersion }}"
          imagePullPolicy: {{ $service.image.pullPolicy }}
          ports:
            - name: http
              containerPort: {{ $service.service.targetPort }}
              protocol: TCP
          livenessProbe:
            httpGet:
              path: /health
              port: http
            initialDelaySeconds: 30
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /ready
              port: http
            initialDelaySeconds: 5
            periodSeconds: 5
          resources:
            {{- toYaml $service.resources | nindent 12 }}
          env:
            - name: ENVIRONMENT
              value: {{ $.Values.global.environment }}
            {{- if $service.env }}
            {{- toYaml $service.env | nindent 12 }}
            {{- end }}
---
{{- end }}
{{- end }}

Monitoring i obserwowalność

Konfiguracja stacku Prometheus

# AI implementuje stack monitoringu
"Skonfiguruj monitoring Prometheus z:
- Service discovery dla Kubernetes
- Niestandardowymi metrykami i alertami
- Dashboardami Grafana
- Konfiguracją AlertManager
- Długoterminowym przechowywaniem z Thanos"

# AI tworzy kompleksowy monitoring
apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
data:
  prometheus.yml: |
    global:
      scrape_interval: 15s
      evaluation_interval: 15s

    alerting:
      alertmanagers:
        - static_configs:
            - targets:
                - alertmanager:9093

    rule_files:
      - "alerts/*.yml"

    scrape_configs:
      - job_name: 'kubernetes-apiservers'
        kubernetes_sd_configs:
          - role: endpoints
        scheme: https
        tls_config:
          ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
        relabel_configs:
          - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
            action: keep
            regex: default;kubernetes;https

      - job_name: 'kubernetes-pods'
        kubernetes_sd_configs:
          - role: pod
        relabel_configs:
          - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
            action: keep
            regex: true
          - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
            action: replace
            target_label: __metrics_path__
            regex: (.+)
          - source_labels: [__address__, __meta_kubernetes_pod_annotation_prometheus_io_port]
            action: replace
            regex: ([^:]+)(?::\d+)?;(\d+)
            replacement: $1:$2
            target_label: __address__

Architektura logowania

Zbieranie logów

Fluentd/Fluent Bit do agregacji logów

Przechowywanie logów

Elasticsearch lub Loki do przechowywania

Analiza logów

Kibana lub Grafana do wizualizacji

Alerty logów

Alerty w czasie rzeczywistym na wzorcach logów

Bezpieczeństwo i zgodność

Pipeline skanowania bezpieczeństwa

# AI implementuje skanowanie bezpieczeństwa
"Stwórz pipeline skanowania bezpieczeństwa z:
- SAST (Static Application Security Testing)
- DAST (Dynamic Application Security Testing)
- Skanowaniem kontenerów
- Skanowaniem podatności zależności
- Sprawdzeniami zgodności infrastruktury"

# AI generuje workflow bezpieczeństwa
name: Skanowanie bezpieczeństwa

on:
  schedule:
    - cron: '0 2 * * *'  # Codziennie o 2:00
  workflow_dispatch:

jobs:
  sast-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Uruchom Semgrep
        uses: returntocorp/semgrep-action@v1
        with:
          config: >-
            p/security-audit
            p/owasp-top-ten
            p/r2c-security-audit

      - name: Uruchom CodeQL
        uses: github/codeql-action/analyze@v2
        with:
          languages: javascript, python

      - name: Skan SonarCloud
        uses: SonarSource/sonarcloud-github-action@master
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

  dependency-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Uruchom Snyk
        uses: snyk/actions/node@master
        env:
          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
        with:
          args: --severity-threshold=high

      - name: OWASP Dependency Check
        uses: dependency-check/Dependency-Check_Action@main
        with:
          project: 'app'
          path: '.'
          format: 'ALL'

  container-scan:
    runs-on: ubuntu-latest
    steps:
      - name: Uruchom Trivy
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: 'fs'
          scan-ref: '.'
          format: 'sarif'
          output: 'trivy-results.sarif'
          severity: 'CRITICAL,HIGH'

      - name: Upload wyników Trivy
        uses: github/codeql-action/upload-sarif@v2
        with:
          sarif_file: 'trivy-results.sarif'

Testowanie infrastruktury

Testowanie Terraform

# AI tworzy testy infrastruktury
"Generuj suite Terratest dla:
- Testowania modułów
- Testowania integracji
- Walidacji zgodności
- Szacowania kosztów
- Testowania destroy"

// AI implementuje testy Go dla Terraform
package test

import (
    "testing"
    "github.com/gruntwork-io/terratest/modules/terraform"
    "github.com/stretchr/testify/assert"
)

func TestTerraformWebAppModule(t *testing.T) {
    t.Parallel()

    terraformOptions := &terraform.Options{
        TerraformDir: "../modules/web-app",
        Vars: map[string]interface{}{
            "environment": "test",
            "region":      "us-east-1",
        },
    }

    defer terraform.Destroy(t, terraformOptions)

    terraform.InitAndApply(t, terraformOptions)

    // Waliduj outputy
    albDns := terraform.Output(t, terraformOptions, "alb_dns_name")
    assert.NotEmpty(t, albDns)

    // Testuj rzeczywistą infrastrukturę
    validateALBIsWorking(t, albDns)
    validateSecurityGroups(t, terraformOptions)
    validateTags(t, terraformOptions)
}

Ćwiczenia praktyczne

Ćwiczenie 1: Kompletna konfiguracja infrastruktury

Zaprojektuj architekturę infrastruktury z AI
Implementuj IaC z Terraform/CloudFormation
Stwórz pipeline CI/CD
Skonfiguruj monitoring i logowanie
Implementuj skanowanie bezpieczeństwa

Ćwiczenie 2: Wdrożenie Kubernetes

Stwórz manifesty Kubernetes z AI
Implementuj charty Helm
Skonfiguruj GitOps z ArgoCD
Skonfiguruj service mesh
Implementuj stack obserwowalności

Ćwiczenie 3: Disaster recovery

Zaprojektuj strategię backupów
Implementuj automatyczne backupy
Stwórz procedury odzyskiwania
Testuj scenariusze failover
Udokumentuj RTO/RPO

Najlepsze praktyki

Wersjonuj wszystko

Przechowuj cały kod infrastruktury w kontroli wersji

Testuj infrastrukturę

Testuj zmiany infrastruktury przed produkcją

Monitoruj wszystko

Kompleksowy monitoring od pierwszego dnia

Automatyzuj bezpieczeństwo

Skanowanie bezpieczeństwa w każdym pipeline’ie

Następne kroki

Głębokie zanurzenie w monitoring

Zaawansowany monitoring i obserwowalność

Strategie migracji

Migracja legacy infrastruktury

Wzorce architektoniczne

Projektowanie architektury cloud-native