Cele 5 caracteristici esențiale (NIST SP 800-145):

1. On-demand self-service
   Provizionezi resurse fără interacțiune umană cu provider-ul.
   CLI: aws ec2 run-instances ... → mașină virtuală în 60 secunde.

2. Broad network access
   Accesibil prin rețea de pe orice dispozitiv (laptop, telefon, API).

3. Resource pooling
   Resursele fizice sunt partajate între clienți (multi-tenancy).
   Nu știi (și nu trebuie să știi) pe ce server fizic rulezi.

4. Rapid elasticity
   Scalare sus/jos automat, aproape instantaneu, aparent infinit.

5. Measured service
   Plătești doar ce consumi (pay-as-you-go). Monitorizare și raportare transparentă.

                 On-Premises                    Cloud
─────────────────────────────────────────────────────────────────
Investiție      CapEx mare (cumperi hardware)   OpEx (plătești lunar)
Provizionare    Săptămâni-luni                  Minute-secunde
Scalare         Manuală, limitată               Automată, elastică
Mentenanță      Tu (patching, hardware, DC)     Provider-ul
Disponibilitate Tu construiești HA              Built-in (multi-AZ, regiuni)
Securitate      Control total                   Responsabilitate partajată
Cost predicibil Da (după investiția inițială)   Variabil (risc de surprize)
Experimentare   Costisitoare (risc)             Ieftină (oprești, nu plătești)

┌─────────────────────────────────────────────────────────────────┐
│                 PIAȚA CLOUD (IaaS+PaaS)                         │
│                                                                  │
│  ┌─────────────────┐  ┌────────────────┐  ┌─────────────────┐  │
│  │     AWS         │  │   Microsoft    │  │   Google Cloud  │  │
│  │   Amazon Web    │  │     Azure      │  │   Platform      │  │
│  │   Services      │  │                │  │   (GCP)         │  │
│  │                 │  │                │  │                 │  │
│  │  ~31% market    │  │  ~25% market   │  │  ~11% market    │  │
│  │  share          │  │  share         │  │  share          │  │
│  │                 │  │                │  │                 │  │
│  │  200+ servicii  │  │  200+ servicii │  │  100+ servicii  │  │
│  │  Cel mai matur  │  │  Integrare     │  │  ML/AI, data,   │  │
│  │  ecosistem      │  │  enterprise    │  │  Kubernetes     │  │
│  │  Startup-uri,   │  │  Microsoft     │  │  (GKE inventat  │  │
│  │  tech companies │  │  (AD, Office)  │  │   K8s)          │  │
│  └─────────────────┘  └────────────────┘  └─────────────────┘  │
│                                                                  │
│  Alți provideri: Oracle Cloud, IBM Cloud, Alibaba Cloud,        │
│  DigitalOcean, Linode/Akamai, Hetzner, OVH                     │
└─────────────────────────────────────────────────────────────────┘

CE GESTIONEZI TU vs. CE GESTIONEAZĂ PROVIDER-UL:

                    On-Prem    IaaS      PaaS      FaaS/     SaaS
                                                   Serverless
──────────────────────────────────────────────────────────────────
Aplicație           TU         TU        TU        TU         Provider
Date                TU         TU        TU        TU         Provider
Runtime             TU         TU        Provider  Provider   Provider
Middleware          TU         TU        Provider  Provider   Provider
OS                  TU         TU        Provider  Provider   Provider
Virtualizare        TU         Provider  Provider  Provider   Provider
Servere             TU         Provider  Provider  Provider   Provider
Stocare             TU         Provider  Provider  Provider   Provider
Networking          TU         Provider  Provider  Provider   Provider
Datacenter fizic    TU         Provider  Provider  Provider   Provider

Exemple concrete:
IaaS:  EC2, Azure VMs, GCE
       → Tu gestionezi OS, patching, aplicația, middleware
PaaS:  Elastic Beanstalk, Azure App Service, Google App Engine, Heroku
       → Tu gestionezi doar codul și datele
FaaS:  Lambda, Azure Functions, Cloud Functions
       → Tu gestionezi doar funcția (codul), nimic altceva
SaaS:  Gmail, Salesforce, Office 365, Slack
       → Tu doar folosești aplicația

Public Cloud:     Resurse partajate, operate de provider, acces prin internet.
                  (AWS, Azure, GCP)

Private Cloud:    Infrastructură cloud dedicată unei singure organizații.
                  (VMware vSphere, OpenStack, Azure Stack)

Hybrid Cloud:     Combinație public + private/on-prem, cu orchestrare unificată.
                  (AWS Outposts, Azure Arc, Anthos)

Multi-Cloud:      Folosirea simultană a mai multor provideri publici.
                  (AWS + GCP, sau AWS + Azure — evitare vendor lock-in)

1. OPERATIONAL EXCELLENCE
   Automatizare operații, IaC, observabilitate, îmbunătățire continuă.
   Practici: runbooks, playbooks, post-incident reviews.

2. SECURITY
   Protecție date, identitate, detecție, răspuns la incidente.
   Practici: least privilege, criptare everywhere, audit logging.

3. RELIABILITY
   Recuperare din eșecuri, scalare la cerere, gestionare schimbări.
   Practici: multi-AZ, health checks, chaos engineering, backup/restore testat.

4. PERFORMANCE EFFICIENCY
   Resurse potrivite pentru cerințe, monitorizare performanță.
   Practici: right-sizing, caching, CDN, alegere tip instanță corect.

5. COST OPTIMIZATION
   Eliminare risipă, alegere model de pricing corect.
   Practici: Reserved Instances, Spot, right-sizing, auto-scaling, cleanup.

6. SUSTAINABILITY
   Minimizare impact de mediu, eficiență energetică.
   Practici: regiuni cu energie verde, right-sizing, serverless.

Design for Failure:        Totul va pica eventual. Proiectează-te pentru asta.
                           Multi-AZ, retry cu backoff, circuit breaker, health checks.

Decouple Components:       Componente independente, comunicare prin API/mesaje.
                           Căderea uneia nu afectează restul.

Elasticity over Capacity:  Nu supradimensiona. Lasă auto-scaling să gestioneze.
                           Pay-for-what-you-use.

Automate Everything:       IaC, CI/CD, auto-healing, auto-scaling.
                           Dacă faci ceva manual de 2 ori, automatizează-l.

Use Managed Services:      Nu reinventa roata. RDS > self-managed PostgreSQL.
                           Concentrează-te pe business logic, nu pe infrastructură.

Think Stateless:           Servere efemere (cattle, not pets).
                           Starea externalizată în S3, DynamoDB, Redis, EFS.

Secure by Default:         Least privilege, criptare, zero trust.
                           Security nu e un layer adăugat, e fundament.

AWS Global Infrastructure (exemplu):

┌─────────────────────────────────────────────────────────────────┐
│                        AWS GLOBAL                                │
│                                                                  │
│  Region: eu-west-1 (Ireland)                                    │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │                                                          │    │
│  │  AZ: eu-west-1a      AZ: eu-west-1b      AZ: eu-west-1c│    │
│  │  ┌──────────────┐   ┌──────────────┐   ┌──────────────┐│    │
│  │  │ Datacenter(s)│   │ Datacenter(s)│   │ Datacenter(s)││    │
│  │  │              │   │              │   │              ││    │
│  │  │ EC2, RDS,    │   │ EC2, RDS,    │   │ EC2, RDS,    ││    │
│  │  │ EBS, etc.    │   │ EBS, etc.    │   │ EBS, etc.    ││    │
│  │  └──────────────┘   └──────────────┘   └──────────────┘│    │
│  │       │                    │                   │         │    │
│  │       └────── Rețea privată de mare viteză, ──┘         │    │
│  │               latență < 2ms între AZ-uri                 │    │
│  └─────────────────────────────────────────────────────────┘    │
│                                                                  │
│  Edge Locations (400+): CloudFront CDN, Route53 DNS, WAF        │
│  Local Zones: extensii în orașe mari (pentru latență ultra-mică)│
│  Wavelength: compute la edge-ul rețelei 5G                      │
│  Outposts: hardware AWS în datacenter-ul TĂU                    │
└─────────────────────────────────────────────────────────────────┘

AZ (Availability Zone):
  - Unul sau mai multe datacentere fizice, izolate de alte AZ-uri
  - Alimentare independentă, cooling independent, networking independent
  - Conectate între ele cu fibră optică de mare viteză (<2ms latență)
  - Proiectare: un dezastru care afectează un AZ NU afectează celelalte

Region:
  - Cluster de AZ-uri (tipic 3, uneori 2-6)
  - Complet independentă de alte regiuni (date NU se replică automat)
  - Alegere pe baza: latență la useri, conformitate juridică, disponibilitate servicii

                    AWS EC2              Azure VM             GCE
────────────────────────────────────────────────────────────────────
General Purpose     t3, m6i, m7g        B, Dv5, Dav5         e2, n2, n2d
Compute Optimized   c6i, c7g            Fsv2                 c2, c2d, h3
Memory Optimized    r6i, x2idn          Ev5, Mv2             m2, m3
Storage Optimized   i3, d3, i4i         Lsv3                 z3
Accelerated (GPU)   p4d, g5, inf2       NCv3, NDv2           a2, g2

Nomenclatură AWS EC2: m6i.xlarge
  m  = familie (general purpose)
  6  = generație
  i  = procesor Intel (g=Graviton ARM, a=AMD)
  xlarge = dimensiune (nano < micro < small < medium < large < xlarge < 2xl...)

On-Demand:          Plătești per oră/secundă. Fără commitment.
                    Cel mai scump, dar cel mai flexibil.
                    Folosire: workloads impredictibile, dev/test, burst.

Reserved Instances: 1 sau 3 ani commitment. Discount 30-72% vs. on-demand.
(RI / Savings Plans) Folosire: workloads stabile, producție, baze de date.

Spot Instances:     Capacitate neutilizată AWS, cu discount până la 90%.
                    POATE FI OPRIT cu 2 minute notificare!
                    Folosire: batch processing, CI/CD, ML training, HPC.

Dedicated Hosts:    Server fizic dedicat ție. Compliance, licențiere.
                    Cel mai scump model.

Comparație (exemplu m6i.xlarge, eu-west-1):
  On-Demand:  ~$0.192/oră  = ~$140/lună
  1yr RI:     ~$0.121/oră  = ~$88/lună   (37% economie)
  3yr RI:     ~$0.077/oră  = ~$56/lună   (60% economie)
  Spot:       ~$0.057/oră  = ~$42/lună   (70% economie, dar interruptibil)

# Creare instanță EC2 cu AWS CLI:
aws ec2 run-instances \
    --image-id ami-0abcdef1234567890 \
    --instance-type t3.medium \
    --key-name my-keypair \
    --security-group-ids sg-0123456789abcdef0 \
    --subnet-id subnet-0123456789abcdef0 \
    --iam-instance-profile Name=EC2-SSM-Role \
    --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=web-server-1},{Key=Environment,Value=production}]' \
    --user-data file://startup-script.sh \
    --block-device-mappings '[{"DeviceName":"/dev/xvda","Ebs":{"VolumeSize":50,"VolumeType":"gp3","Encrypted":true}}]' \
    --metadata-options "HttpTokens=required,HttpEndpoint=enabled"

# User data script (execut la prima pornire):
#!/bin/bash
yum update -y
yum install -y httpd
systemctl start httpd
systemctl enable httpd
echo "<h1>Hello from $(hostname)</h1>" > /var/www/html/index.html

resource "aws_instance" "web" {
  ami                    = data.aws_ami.amazon_linux.id
  instance_type          = "t3.medium"
  subnet_id              = aws_subnet.private[0].id
  vpc_security_group_ids = [aws_security_group.web.id]
  iam_instance_profile   = aws_iam_instance_profile.ec2.name
  key_name               = aws_key_pair.deployer.key_name

  root_block_device {
    volume_size = 50
    volume_type = "gp3"
    encrypted   = true
  }

  metadata_options {
    http_tokens = "required"    # IMDSv2 obligatoriu (securitate)
  }

  user_data = base64encode(templatefile("${path.module}/userdata.sh", {
    app_version = var.app_version
    environment = var.environment
  }))

  tags = {
    Name        = "web-server-${count.index + 1}"
    Environment = var.environment
  }

  lifecycle {
    create_before_destroy = true
  }
}

┌─────────────────────────────────────────────────────────────────┐
│                CONTAINERE ÎN CLOUD                               │
│                                                                  │
│  ┌────────────────────────────────────────────────────────────┐ │
│  │ COMPUTE:  Unde rulează containerele?                        │ │
│  │                                                             │ │
│  │  EC2 / VMs           Fargate / ACI       App Runner /      │ │
│  │  (self-managed)      (serverless          Cloud Run         │ │
│  │  Tu gestionezi       containers)         (fully managed     │ │
│  │  nodurile            Fără servere         PaaS pentru       │ │
│  │                      de gestionat         containere)       │ │
│  └────────────────────────────────────────────────────────────┘ │
│                                                                  │
│  ┌────────────────────────────────────────────────────────────┐ │
│  │ ORCHESTRARE:  Cine gestionează containerele?                │ │
│  │                                                             │ │
│  │  ECS                 EKS / AKS / GKE    Docker Compose     │ │
│  │  (AWS-native,        (Kubernetes         (dev/test only,    │ │
│  │   simplu)            managed)            nu producție)      │ │
│  └────────────────────────────────────────────────────────────┘ │
│                                                                  │
│  ┌────────────────────────────────────────────────────────────┐ │
│  │ REGISTRY:  Unde stocăm imaginile?                           │ │
│  │                                                             │ │
│  │  ECR / ACR / GCR / Artifact Registry / Docker Hub          │ │
│  └────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘

# ECS Cluster
resource "aws_ecs_cluster" "main" {
  name = "app-cluster"

  setting {
    name  = "containerInsights"
    value = "enabled"
  }
}

# Task Definition
resource "aws_ecs_task_definition" "app" {
  family                   = "app-task"
  network_mode             = "awsvpc"
  requires_compatibilities = ["FARGATE"]
  cpu                      = "512"      # 0.5 vCPU
  memory                   = "1024"     # 1 GB
  execution_role_arn       = aws_iam_role.ecs_execution.arn
  task_role_arn            = aws_iam_role.ecs_task.arn

  container_definitions = jsonencode([{
    name      = "app"
    image     = "${aws_ecr_repository.app.repository_url}:latest"
    essential = true

    portMappings = [{
      containerPort = 8000
      protocol      = "tcp"
    }]

    environment = [
      { name = "APP_ENV", value = "production" }
    ]

    secrets = [
      { name = "DATABASE_URL", valueFrom = aws_ssm_parameter.db_url.arn }
    ]

    logConfiguration = {
      logDriver = "awslogs"
      options = {
        awslogs-group         = aws_cloudwatch_log_group.app.name
        awslogs-region        = var.region
        awslogs-stream-prefix = "app"
      }
    }

    healthCheck = {
      command     = ["CMD-SHELL", "curl -f http://localhost:8000/health || exit 1"]
      interval    = 30
      timeout     = 5
      retries     = 3
      startPeriod = 60
    }
  }])
}

# ECS Service
resource "aws_ecs_service" "app" {
  name            = "app-service"
  cluster         = aws_ecs_cluster.main.id
  task_definition = aws_ecs_task_definition.app.arn
  desired_count   = 3
  launch_type     = "FARGATE"

  network_configuration {
    subnets          = aws_subnet.private[*].id
    security_groups  = [aws_security_group.ecs.id]
    assign_public_ip = false
  }

  load_balancer {
    target_group_arn = aws_lb_target_group.app.arn
    container_name   = "app"
    container_port   = 8000
  }

  deployment_circuit_breaker {
    enable   = true
    rollback = true      # Rollback automat la deploy eșuat
  }
}

Ideal pentru:
  ✅ Event-driven (S3 upload → procesare, API Gateway → logică, SQS → worker)
  ✅ Trafic variabil / sporadic (de la 0 la mii de request-uri)
  ✅ Microservicii mici, funcții individuale
  ✅ Prototipare rapidă
  ✅ Cron jobs / batch processing

NU ideal pentru:
  ❌ Workloads cu latență constantă necesară (cold start: 100ms-3s)
  ❌ Procesare de lungă durată (>15 min pe Lambda)
  ❌ Workloads compute-intensive constante (mai scump decât EC2)
  ❌ Aplicații stateful complexe

# lambda_function.py — handler Lambda
import json
import boto3
import os
from datetime import datetime

s3 = boto3.client('s3')
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table(os.environ['TABLE_NAME'])

def handler(event, context):
    """
    Triggered de: API Gateway, S3 Event, SQS, EventBridge, etc.

    event: datele de intrare (format depinde de sursa trigger)
    context: metadata runtime (request_id, time_remaining, memory_limit)
    """

    # Exemplu 1: API Gateway trigger (REST API)
    if 'httpMethod' in event:
        method = event['httpMethod']
        path = event['path']
        body = json.loads(event.get('body', '{}'))

        if method == 'GET' and path == '/users':
            result = table.scan()
            return {
                'statusCode': 200,
                'headers': {'Content-Type': 'application/json'},
                'body': json.dumps(result['Items'], default=str)
            }

        elif method == 'POST' and path == '/users':
            table.put_item(Item={
                'id': context.aws_request_id,
                'name': body['name'],
                'email': body['email'],
                'created_at': datetime.now().isoformat()
            })
            return {
                'statusCode': 201,
                'body': json.dumps({'message': 'User created'})
            }

    # Exemplu 2: S3 Event trigger (imagine uploadată → procesare)
    if 'Records' in event and event['Records'][0].get('eventSource') == 'aws:s3':
        bucket = event['Records'][0]['s3']['bucket']['name']
        key = event['Records'][0]['s3']['object']['key']
        print(f"New file uploaded: s3://{bucket}/{key}")
        # Procesare: resize imagine, extragere text OCR, etc.
        return {'statusCode': 200}

    return {'statusCode': 400, 'body': 'Unknown event source'}

# Terraform Lambda
resource "aws_lambda_function" "api" {
  function_name = "api-handler"
  role          = aws_iam_role.lambda.arn
  handler       = "lambda_function.handler"
  runtime       = "python3.12"
  timeout       = 30
  memory_size   = 256

  filename         = data.archive_file.lambda.output_path
  source_code_hash = data.archive_file.lambda.output_base64sha256

  environment {
    variables = {
      TABLE_NAME  = aws_dynamodb_table.users.name
      ENVIRONMENT = "production"
    }
  }

  tracing_config {
    mode = "Active"    # AWS X-Ray tracing
  }
}

# API Gateway → Lambda
resource "aws_apigatewayv2_api" "http" {
  name          = "http-api"
  protocol_type = "HTTP"
}

resource "aws_apigatewayv2_integration" "lambda" {
  api_id             = aws_apigatewayv2_api.http.id
  integration_type   = "AWS_PROXY"
  integration_uri    = aws_lambda_function.api.invoke_arn
  payload_format_version = "2.0"
}

resource "aws_apigatewayv2_route" "default" {
  api_id    = aws_apigatewayv2_api.http.id
  route_key = "$default"
  target    = "integrations/${aws_apigatewayv2_integration.lambda.id}"
}

# Auto Scaling Group cu Launch Template
resource "aws_autoscaling_group" "web" {
  name                = "web-asg"
  desired_capacity    = 3
  min_size            = 2
  max_size            = 20
  vpc_zone_identifier = aws_subnet.private[*].id
  target_group_arns   = [aws_lb_target_group.web.arn]
  health_check_type   = "ELB"

  launch_template {
    id      = aws_launch_template.web.id
    version = "$Latest"
  }

  instance_refresh {
    strategy = "Rolling"
    preferences {
      min_healthy_percentage = 75
    }
  }

  tag {
    key                 = "Name"
    value               = "web-server"
    propagate_at_launch = true
  }
}

# Scaling Policy — Target Tracking (cel mai simplu și recomandat):
resource "aws_autoscaling_policy" "cpu" {
  name                   = "cpu-target-tracking"
  autoscaling_group_name = aws_autoscaling_group.web.name
  policy_type            = "TargetTrackingScaling"

  target_tracking_configuration {
    predefined_metric_specification {
      predefined_metric_type = "ASGAverageCPUUtilization"
    }
    target_value = 60.0    # Menține CPU la ~60% în medie
  }
}

# Scheduled Scaling (predictibil — ex: ore de vârf):
resource "aws_autoscaling_schedule" "morning_scale_up" {
  autoscaling_group_name = aws_autoscaling_group.web.name
  scheduled_action_name  = "morning-scale-up"
  min_size               = 5
  max_size               = 30
  desired_capacity       = 10
  recurrence             = "0 8 * * MON-FRI"    # Luni-Vineri la 08:00
}

┌──────────────────────────────────────────────────────────────────┐
│  VPC: 10.0.0.0/16                                                │
│                                                                   │
│  ┌─────────── AZ-a ──────────┐  ┌─────────── AZ-b ─────────┐   │
│  │                            │  │                           │   │
│  │  Public Subnet             │  │  Public Subnet            │   │
│  │  10.0.1.0/24              │  │  10.0.2.0/24             │   │
│  │  ┌────────┐ ┌────────┐   │  │  ┌────────┐ ┌────────┐  │   │
│  │  │  ALB   │ │NAT GW  │   │  │  │  ALB   │ │NAT GW  │  │   │
│  │  └────────┘ └────────┘   │  │  └────────┘ └────────┘  │   │
│  │                            │  │                           │   │
│  │  Private Subnet (App)      │  │  Private Subnet (App)     │   │
│  │  10.0.11.0/24             │  │  10.0.12.0/24            │   │
│  │  ┌────────┐ ┌────────┐   │  │  ┌────────┐ ┌────────┐  │   │
│  │  │ EC2/ECS│ │ EC2/ECS│   │  │  │ EC2/ECS│ │ EC2/ECS│  │   │
│  │  └────────┘ └────────┘   │  │  └────────┘ └────────┘  │   │
│  │                            │  │                           │   │
│  │  Private Subnet (DB)       │  │  Private Subnet (DB)      │   │
│  │  10.0.21.0/24             │  │  10.0.22.0/24            │   │
│  │  ┌────────┐               │  │  ┌────────┐              │   │
│  │  │  RDS   │ (primary)     │  │  │  RDS   │ (standby)   │   │
│  │  └────────┘               │  │  └────────┘              │   │
│  │                            │  │                           │   │
│  └────────────────────────────┘  └───────────────────────────┘   │
│                                                                   │
│  ┌─────────┐                                                     │
│  │ Internet│←── Internet Gateway (IGW)                           │
│  │ Gateway │                                                     │
│  └─────────┘                                                     │
│                                                                   │
│  Route Tables:                                                    │
│    Public:  0.0.0.0/0 → IGW        (acces direct internet)       │
│    Private: 0.0.0.0/0 → NAT GW    (internet outbound-only)      │
│    DB:      no default route        (complet izolat de internet)  │
│                                                                   │
│  VPC Endpoints:                                                   │
│    S3 Gateway Endpoint (trafic S3 fără a trece prin internet)    │
│    Interface Endpoints: ECR, CloudWatch, SSM, Secrets Manager     │
└──────────────────────────────────────────────────────────────────┘

module "vpc" {
  source  = "terraform-aws-modules/vpc/aws"
  version = "~> 5.0"

  name = "production-vpc"
  cidr = "10.0.0.0/16"

  azs             = ["eu-west-1a", "eu-west-1b", "eu-west-1c"]
  public_subnets  = ["10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24"]
  private_subnets = ["10.0.11.0/24", "10.0.12.0/24", "10.0.13.0/24"]
  database_subnets = ["10.0.21.0/24", "10.0.22.0/24", "10.0.23.0/24"]

  enable_nat_gateway     = true
  single_nat_gateway     = false     # Un NAT GW per AZ (HA)
  one_nat_gateway_per_az = true

  enable_dns_hostnames = true
  enable_dns_support   = true

  create_database_subnet_group       = true
  create_database_subnet_route_table = true

  # VPC Flow Logs
  enable_flow_log                      = true
  create_flow_log_cloudwatch_log_group = true
  create_flow_log_iam_role             = true

  tags = {
    Environment = "production"
    Terraform   = "true"
  }

  public_subnet_tags = {
    "kubernetes.io/role/elb" = "1"
  }

  private_subnet_tags = {
    "kubernetes.io/role/internal-elb" = "1"
  }
}

# Security Group — web servers
resource "aws_security_group" "web" {
  name_prefix = "web-"
  vpc_id      = module.vpc.vpc_id

  ingress {
    from_port       = 8000
    to_port         = 8000
    protocol        = "tcp"
    security_groups = [aws_security_group.alb.id]    # Doar de la ALB
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  lifecycle {
    create_before_destroy = true
  }
}

# Security Group — database
resource "aws_security_group" "db" {
  name_prefix = "db-"
  vpc_id      = module.vpc.vpc_id

  ingress {
    from_port       = 5432
    to_port         = 5432
    protocol        = "tcp"
    security_groups = [aws_security_group.web.id]    # Doar de la app servers
  }

  # Fără egress către internet → complet izolat
}

                     AWS                    Azure               GCP
──────────────────────────────────────────────────────────────────────
Layer 7 (HTTP/S)    ALB                   App Gateway          HTTP(S) LB
Layer 4 (TCP/UDP)   NLB                   Azure LB             TCP/UDP LB
DNS-based           Route53               Traffic Manager       Cloud DNS
Global              CloudFront + ALB      Front Door            Global LB

# Application Load Balancer (ALB) — Terraform
resource "aws_lb" "main" {
  name               = "app-alb"
  internal           = false
  load_balancer_type = "application"
  security_groups    = [aws_security_group.alb.id]
  subnets            = module.vpc.public_subnets

  enable_deletion_protection = true

  access_logs {
    bucket  = aws_s3_bucket.alb_logs.id
    enabled = true
  }
}

resource "aws_lb_listener" "https" {
  load_balancer_arn = aws_lb.main.arn
  port              = 443
  protocol          = "HTTPS"
  ssl_policy        = "ELBSecurityPolicy-TLS13-1-2-2021-06"
  certificate_arn   = aws_acm_certificate.main.arn

  default_action {
    type             = "forward"
    target_group_arn = aws_lb_target_group.app.arn
  }
}

# Redirect HTTP → HTTPS
resource "aws_lb_listener" "http_redirect" {
  load_balancer_arn = aws_lb.main.arn
  port              = 80
  protocol          = "HTTP"

  default_action {
    type = "redirect"
    redirect {
      port        = "443"
      protocol    = "HTTPS"
      status_code = "HTTP_301"
    }
  }
}

# Path-based routing (microservicii):
resource "aws_lb_listener_rule" "api" {
  listener_arn = aws_lb_listener.https.arn
  priority     = 100

  condition {
    path_pattern { values = ["/api/*"] }
  }
  action {
    type             = "forward"
    target_group_arn = aws_lb_target_group.api.arn
  }
}

# Route53 — DNS
resource "aws_route53_zone" "main" {
  name = "example.com"
}

resource "aws_route53_record" "app" {
  zone_id = aws_route53_zone.main.zone_id
  name    = "app.example.com"
  type    = "A"

  alias {
    name                   = aws_lb.main.dns_name
    zone_id                = aws_lb.main.zone_id
    evaluate_target_health = true
  }
}

# CloudFront CDN
resource "aws_cloudfront_distribution" "cdn" {
  enabled             = true
  default_root_object = "index.html"
  aliases             = ["app.example.com"]
  price_class         = "PriceClass_100"    # Only NA + EU (mai ieftin)

  origin {
    domain_name = aws_lb.main.dns_name
    origin_id   = "alb"

    custom_origin_config {
      http_port              = 80
      https_port             = 443
      origin_protocol_policy = "https-only"
      origin_ssl_protocols   = ["TLSv1.2"]
    }
  }

  # Cache static assets agresiv, bypass cache pentru API:
  ordered_cache_behavior {
    path_pattern     = "/api/*"
    target_origin_id = "alb"
    allowed_methods  = ["GET", "HEAD", "OPTIONS", "PUT", "POST", "PATCH", "DELETE"]
    cached_methods   = ["GET", "HEAD"]

    cache_policy_id          = data.aws_cloudfront_cache_policy.disabled.id
    origin_request_policy_id = data.aws_cloudfront_origin_request_policy.all_viewer.id

    viewer_protocol_policy = "redirect-to-https"
  }

  default_cache_behavior {
    target_origin_id       = "alb"
    allowed_methods        = ["GET", "HEAD"]
    cached_methods         = ["GET", "HEAD"]
    cache_policy_id        = data.aws_cloudfront_cache_policy.optimized.id
    viewer_protocol_policy = "redirect-to-https"
    compress               = true
  }

  viewer_certificate {
    acm_certificate_arn      = aws_acm_certificate.us_east_1.arn    # MUST be us-east-1!
    ssl_support_method       = "sni-only"
    minimum_protocol_version = "TLSv1.2_2021"
  }

  restrictions {
    geo_restriction { restriction_type = "none" }
  }
}

resource "aws_s3_bucket" "data" {
  bucket = "mycompany-production-data"
}

resource "aws_s3_bucket_versioning" "data" {
  bucket = aws_s3_bucket.data.id
  versioning_configuration { status = "Enabled" }
}

resource "aws_s3_bucket_server_side_encryption_configuration" "data" {
  bucket = aws_s3_bucket.data.id
  rule {
    apply_server_side_encryption_by_default {
      sse_algorithm     = "aws:kms"
      kms_master_key_id = aws_kms_key.s3.arn
    }
    bucket_key_enabled = true
  }
}

# Lifecycle rules — optimizare costuri automate:
resource "aws_s3_bucket_lifecycle_configuration" "data" {
  bucket = aws_s3_bucket.data.id

  rule {
    id     = "archive-old-data"
    status = "Enabled"

    transition {
      days          = 90
      storage_class = "STANDARD_IA"     # Infrequent Access: -40% cost
    }
    transition {
      days          = 180
      storage_class = "GLACIER_IR"      # Glacier Instant Retrieval: -68%
    }
    transition {
      days          = 365
      storage_class = "DEEP_ARCHIVE"    # Deep Archive: -95% cost
    }

    noncurrent_version_expiration {
      noncurrent_days = 30              # Șterge versiuni vechi după 30 zile
    }
  }
}

# Block Public Access (MEREU activat în producție):
resource "aws_s3_bucket_public_access_block" "data" {
  bucket                  = aws_s3_bucket.data.id
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

Clase de stocare S3:
  S3 Standard:          Acces frecvent, latență mică          ~$0.023/GB
  S3 Standard-IA:       Acces rar (>30 zile), cost per acces  ~$0.0125/GB
  S3 One Zone-IA:       Ca IA dar un singur AZ (mai puțin HA) ~$0.01/GB
  S3 Glacier Instant:   Arhivare cu acces instant (ms)         ~$0.004/GB
  S3 Glacier Flexible:  Arhivare, retrieval ore                ~$0.0036/GB
  S3 Deep Archive:      Arhivare lungă (7-10 ani), 12h retr.  ~$0.00099/GB
  S3 Intelligent-Tier:  Mișcă automat între clase              ~$0.023/GB + fee

┌─────────────────────────────────────────────────────────────────┐
│  Tip             AWS                Azure            GCP        │
├─────────────────────────────────────────────────────────────────┤
│  Relațional      RDS (PostgreSQL,   Azure SQL DB     Cloud SQL  │
│  (managed)       MySQL, MariaDB)    Azure DB for PG  AlloyDB    │
│                  Aurora (PG/MySQL)                               │
│                                                                  │
│  NoSQL Document  DynamoDB           CosmosDB         Firestore  │
│                  DocumentDB                                      │
│                                                                  │
│  Key-Value       ElastiCache        Azure Cache      Memorystore│
│  / Cache         (Redis, Memcached) (Redis)          (Redis)    │
│                                                                  │
│  Graph           Neptune            CosmosDB (Gremlin) Neo4j AE │
│                                                                  │
│  Time-series     Timestream         Azure Data Exp.  Bigtable   │
│                                                                  │
│  Search          OpenSearch         Cognitive Search  —          │
└─────────────────────────────────────────────────────────────────┘

# RDS PostgreSQL cu Multi-AZ (High Availability)
resource "aws_db_instance" "main" {
  identifier     = "app-database"
  engine         = "postgres"
  engine_version = "16.2"
  instance_class = "db.r6g.large"     # Graviton (ARM) — preț/performanță optim

  allocated_storage     = 100
  max_allocated_storage = 500          # Auto-scaling stocare
  storage_type          = "gp3"
  storage_encrypted     = true
  kms_key_id            = aws_kms_key.rds.arn

  db_name  = "appdb"
  username = "dbadmin"
  password = random_password.db.result
  port     = 5432

  multi_az               = true        # Standby în alt AZ (failover automat)
  db_subnet_group_name   = aws_db_subnet_group.main.name
  vpc_security_group_ids = [aws_security_group.db.id]

  backup_retention_period = 14         # 14 zile de backup automate
  backup_window           = "03:00-04:00"
  maintenance_window      = "sun:04:00-sun:05:00"

  performance_insights_enabled = true
  monitoring_interval          = 60
  monitoring_role_arn          = aws_iam_role.rds_monitoring.arn

  deletion_protection = true
  skip_final_snapshot = false
  final_snapshot_identifier = "app-database-final"

  tags = { Environment = "production" }
}

# Stocare password în Secrets Manager:
resource "aws_secretsmanager_secret" "db" {
  name = "production/database/credentials"
}

resource "aws_secretsmanager_secret_version" "db" {
  secret_id = aws_secretsmanager_secret.db.id
  secret_string = jsonencode({
    username = aws_db_instance.main.username
    password = random_password.db.result
    host     = aws_db_instance.main.address
    port     = aws_db_instance.main.port
    dbname   = aws_db_instance.main.db_name
  })
}

// ❌ GREȘIT — admin access pe tot:
{
    "Effect": "Allow",
    "Action": "*",
    "Resource": "*"
}

// ✅ CORECT — doar ce e necesar:
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "ReadOnlyS3Bucket",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::my-app-data",
                "arn:aws:s3:::my-app-data/*"
            ]
        },
        {
            "Sid": "WriteSpecificDynamoTable",
            "Effect": "Allow",
            "Action": [
                "dynamodb:PutItem",
                "dynamodb:GetItem",
                "dynamodb:UpdateItem",
                "dynamodb:Query"
            ],
            "Resource": "arn:aws:dynamodb:eu-west-1:123456789:table/users"
        }
    ]
}

# Roluri IAM pentru servicii (nu chei statice niciodată!)

# Rol pentru Lambda:
resource "aws_iam_role" "lambda" {
  name = "lambda-execution-role"
  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Action = "sts:AssumeRole"
      Effect = "Allow"
      Principal = { Service = "lambda.amazonaws.com" }
    }]
  })
}

resource "aws_iam_role_policy_attachment" "lambda_basic" {
  role       = aws_iam_role.lambda.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
}

# Politică custom inline:
resource "aws_iam_role_policy" "lambda_s3" {
  name = "lambda-s3-access"
  role = aws_iam_role.lambda.id
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Effect   = "Allow"
      Action   = ["s3:GetObject"]
      Resource = "${aws_s3_bucket.data.arn}/*"
    }]
  })
}

# CloudTrail — auditează TOATE apelurile API AWS:
resource "aws_cloudtrail" "main" {
  name                          = "org-trail"
  s3_bucket_name                = aws_s3_bucket.cloudtrail.id
  include_global_service_events = true
  is_multi_region_trail         = true
  enable_log_file_validation    = true
  kms_key_id                    = aws_kms_key.cloudtrail.arn

  event_selector {
    read_write_type           = "All"
    include_management_events = true

    data_resource {
      type   = "AWS::S3::Object"
      values = ["arn:aws:s3"]
    }
  }
}

# AWS Config — verificare continuă a conformității:
resource "aws_config_config_rule" "s3_encryption" {
  name = "s3-bucket-server-side-encryption-enabled"
  source {
    owner             = "AWS"
    source_identifier = "S3_BUCKET_SERVER_SIDE_ENCRYPTION_ENABLED"
  }
}

resource "aws_config_config_rule" "restricted_ssh" {
  name = "restricted-ssh"
  source {
    owner             = "AWS"
    source_identifier = "INCOMING_SSH_DISABLED"
  }
}

infrastructure/
├── modules/                          # Module reutilizabile
│   ├── vpc/
│   │   ├── main.tf
│   │   ├── variables.tf
│   │   ├── outputs.tf
│   │   └── README.md
│   ├── ecs-service/
│   ├── rds/
│   ├── lambda-function/
│   └── monitoring/
│
├── environments/                     # Configurări per mediu
│   ├── dev/
│   │   ├── main.tf                   # Apelează modulele
│   │   ├── variables.tf
│   │   ├── terraform.tfvars          # Valori specifice dev
│   │   └── backend.tf                # S3 backend config
│   ├── staging/
│   └── production/
│       ├── main.tf
│       ├── variables.tf
│       ├── terraform.tfvars
│       └── backend.tf
│
├── global/                           # Resurse globale (IAM, Route53 zone)
│   └── iam/
│
└── .github/workflows/terraform.yml   # CI/CD pipeline

# === Terraform State Remote (S3 + DynamoDB) ===
terraform {
  required_version = ">= 1.5"

  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }

  backend "s3" {
    bucket         = "mycompany-terraform-state"
    key            = "production/infrastructure.tfstate"
    region         = "eu-west-1"
    dynamodb_table = "terraform-locks"
    encrypt        = true
  }
}

# === Data Sources (referire resurse existente) ===
data "aws_caller_identity" "current" {}
data "aws_region" "current" {}

data "aws_ami" "amazon_linux" {
  most_recent = true
  owners      = ["amazon"]
  filter {
    name   = "name"
    values = ["al2023-ami-*-x86_64"]
  }
}

# === for_each (multiple resurse din map) ===
variable "services" {
  type = map(object({
    cpu    = number
    memory = number
    port   = number
  }))
  default = {
    api     = { cpu = 512, memory = 1024, port = 8000 }
    worker  = { cpu = 1024, memory = 2048, port = 0 }
    web     = { cpu = 256, memory = 512, port = 3000 }
  }
}

resource "aws_ecs_service" "services" {
  for_each = var.services

  name            = each.key
  cluster         = aws_ecs_cluster.main.id
  task_definition = aws_ecs_task_definition.services[each.key].arn
  desired_count   = each.key == "worker" ? 2 : 3
  launch_type     = "FARGATE"

  # ... configurare ...
}

# === Moved blocks (refactoring fără distrugere) ===
moved {
  from = aws_instance.web
  to   = module.compute.aws_instance.web
}

# === Import (adoptă resurse existente în Terraform) ===
import {
  to = aws_s3_bucket.existing
  id = "my-existing-bucket-name"
}

# CloudWatch Dashboard
resource "aws_cloudwatch_dashboard" "main" {
  dashboard_name = "Production-Overview"
  dashboard_body = jsonencode({
    widgets = [
      {
        type = "metric"
        properties = {
          title   = "ALB Request Count"
          metrics = [["AWS/ApplicationELB", "RequestCount", "LoadBalancer", aws_lb.main.arn_suffix]]
          period  = 300
          stat    = "Sum"
        }
      },
      {
        type = "metric"
        properties = {
          title   = "ECS CPU Utilization"
          metrics = [["AWS/ECS", "CPUUtilization", "ClusterName", "app-cluster", "ServiceName", "app-service"]]
          period  = 300
          stat    = "Average"
        }
      },
      {
        type = "metric"
        properties = {
          title   = "RDS Connections"
          metrics = [["AWS/RDS", "DatabaseConnections", "DBInstanceIdentifier", "app-database"]]
          period  = 300
        }
      }
    ]
  })
}

# CloudWatch Alarms
resource "aws_cloudwatch_metric_alarm" "high_5xx" {
  alarm_name          = "high-5xx-errors"
  comparison_operator = "GreaterThanThreshold"
  evaluation_periods  = 2
  metric_name         = "HTTPCode_Target_5XX_Count"
  namespace           = "AWS/ApplicationELB"
  period              = 300
  statistic           = "Sum"
  threshold           = 50
  alarm_description   = "High 5xx error rate on ALB"

  dimensions = {
    LoadBalancer = aws_lb.main.arn_suffix
  }

  alarm_actions = [aws_sns_topic.alerts.arn]
  ok_actions    = [aws_sns_topic.alerts.arn]
}

resource "aws_cloudwatch_metric_alarm" "rds_cpu" {
  alarm_name          = "rds-high-cpu"
  comparison_operator = "GreaterThanThreshold"
  evaluation_periods  = 3
  metric_name         = "CPUUtilization"
  namespace           = "AWS/RDS"
  period              = 300
  statistic           = "Average"
  threshold           = 80
  alarm_description   = "RDS CPU > 80% for 15 minutes"

  dimensions = {
    DBInstanceIdentifier = aws_db_instance.main.identifier
  }

  alarm_actions = [aws_sns_topic.alerts.arn]
}

1. VIZIBILITATE — Înțelege unde se duc banii
   - AWS Cost Explorer, Billing Dashboard
   - Tag-uri pe TOATE resursele (Environment, Team, Project, CostCenter)
   - Buget alerte: AWS Budgets → SNS → Slack/Email

2. OPTIMIZARE — Reduce risipa
   - Right-sizing: instanțe supradimensionate (Compute Optimizer)
   - Savings Plans / Reserved Instances: workloads stabile (30-60% economie)
   - Spot Instances: workloads tolerante la întrerupere (70-90% economie)
   - S3 Lifecycle: mută date vechi în clase mai ieftine automat
   - Oprește resurse dev/test în weekend: Instance Scheduler
   - Șterge resurse orfane: EBS volumes, Elastic IPs, snapshots vechi

3. GUVERNANȚĂ — Controlează și previne
   - Service Control Policies (SCP): limitează ce pot face conturile
   - AWS Budgets cu acțiuni automate
   - Tagging enforcement (AWS Config rules)

# AWS Budget cu alertă
resource "aws_budgets_budget" "monthly" {
  name         = "monthly-total"
  budget_type  = "COST"
  limit_amount = "5000"
  limit_unit   = "USD"
  time_unit    = "MONTHLY"

  notification {
    comparison_operator        = "GREATER_THAN"
    threshold                  = 80            # La 80% din buget
    threshold_type             = "PERCENTAGE"
    notification_type          = "ACTUAL"
    subscriber_email_addresses = ["finops@company.com"]
  }

  notification {
    comparison_operator        = "GREATER_THAN"
    threshold                  = 100           # La 100% (budget depășit)
    threshold_type             = "PERCENTAGE"
    notification_type          = "FORECASTED"  # Prognoza depășirii
    subscriber_email_addresses = ["finops@company.com", "cto@company.com"]
  }
}

# Tag policy enforcement:
resource "aws_config_config_rule" "required_tags" {
  name = "required-tags"
  source {
    owner             = "AWS"
    source_identifier = "REQUIRED_TAGS"
  }
  input_parameters = jsonencode({
    tag1Key = "Environment"
    tag2Key = "Team"
    tag3Key = "Project"
  })
}

Arhitectură serverless completă (exemplu e-commerce):

┌──────────────────────────────────────────────────────────────────┐
│                                                                   │
│  CloudFront (CDN)                                                │
│       │                                                          │
│       ├── S3 (static assets: React/Vue frontend)                │
│       │                                                          │
│       └── API Gateway (REST/HTTP API)                            │
│               │                                                  │
│       ┌───────┴────────┐                                        │
│       │                │                                        │
│  Lambda: /products  Lambda: /orders                             │
│       │                │                                        │
│       ▼                ▼                                        │
│  DynamoDB           DynamoDB          ┌─────────────────┐       │
│  (products)         (orders)          │ EventBridge     │       │
│                        │              │ (event bus)      │       │
│                        └──────────────┤                  │       │
│                                       │ order.created    │       │
│                    ┌──────────────────┤ order.paid       │       │
│                    │                  │ order.shipped     │       │
│                    ▼                  └─────────────────┘       │
│               Lambda:                        │                   │
│           payment-processor                  ▼                   │
│                    │                  Lambda:                     │
│                    ▼              send-notification               │
│               Stripe API               │                         │
│                                        ▼                         │
│                                   SES (email)                    │
│                                   SNS (push)                     │
│                                                                   │
│  Cognito (autentificare)    WAF (protecție)    X-Ray (tracing)  │
└──────────────────────────────────────────────────────────────────┘

Servicii de messaging AWS:

SQS (Simple Queue Service):
  - Message queue (point-to-point)
  - Standard: at-least-once, throughput nelimitat
  - FIFO: exactly-once, ordinea garantată, 3000 msg/s
  - Dead Letter Queue: mesaje eșuate → analiză

SNS (Simple Notification Service):
  - Pub/Sub (fan-out: un mesaj → mulți consumatori)
  - Topic → subscriptions (Lambda, SQS, HTTP, email, SMS)

EventBridge:
  - Event bus avansat (routing pe baza conținutului evenimentului)
  - Reguli: if event matches pattern → trigger target
  - 100+ integrări native (AWS services + SaaS)

Kinesis:
  - Real-time streaming (ca Kafka managed)
  - Kinesis Data Streams: ingestion real-time
  - Kinesis Firehose: delivery la S3/Redshift/OpenSearch

# Pattern: SQS + Lambda (procesare asincronă fiabilă)
resource "aws_sqs_queue" "orders" {
  name                       = "order-processing"
  visibility_timeout_seconds = 300           # 5 min (6× Lambda timeout)
  message_retention_seconds  = 1209600       # 14 zile
  receive_wait_time_seconds  = 20            # Long polling (eficient)
  redrive_policy = jsonencode({
    deadLetterTargetArn = aws_sqs_queue.orders_dlq.arn
    maxReceiveCount     = 3                  # După 3 eșecuri → DLQ
  })
}

resource "aws_sqs_queue" "orders_dlq" {
  name                      = "order-processing-dlq"
  message_retention_seconds = 1209600
}

resource "aws_lambda_event_source_mapping" "sqs_lambda" {
  event_source_arn                   = aws_sqs_queue.orders.arn
  function_name                      = aws_lambda_function.process_order.arn
  batch_size                         = 10
  maximum_batching_window_in_seconds = 5
  function_response_types            = ["ReportBatchItemFailures"]
}

Strategii DR (de la cea mai ieftină la cea mai rapidă):

┌────────────────────────────────────────────────────────────────┐
│ Strategie       │ RPO        │ RTO        │ Cost    │ Descriere│
├────────────────────────────────────────────────────────────────┤
│ Backup & Restore│ Ore        │ Ore-Zile   │ $       │ Backup   │
│                 │            │            │         │ S3 cross-│
│                 │            │            │         │ region   │
├────────────────────────────────────────────────────────────────┤
│ Pilot Light     │ Minute     │ Ore        │ $$      │ DB repli-│
│                 │            │            │         │ cat, comp│
│                 │            │            │         │ ute oprit│
├────────────────────────────────────────────────────────────────┤
│ Warm Standby    │ Secunde    │ Minute     │ $$$     │ Env mini-│
│                 │            │            │         │ mal activ│
│                 │            │            │         │ scale up │
│                 │            │            │         │ la DR    │
├────────────────────────────────────────────────────────────────┤
│ Multi-Site      │ ~0         │ ~0         │ $$$$    │ Active-  │
│ Active-Active   │(real-time) │(automat)   │         │ active   │
│                 │            │            │         │ ambele   │
│                 │            │            │         │ regiuni  │
└────────────────────────────────────────────────────────────────┘

RPO = Recovery Point Objective (cât de multe date poți pierde)
RTO = Recovery Time Objective (cât durează să revii online)

1. Circuit Breaker:   Oprește apelurile la un serviciu defect
                      pentru a evita cascading failure.

2. Retry + Backoff:   Reîncercare cu delay exponențial
                      (1s, 2s, 4s, 8s... + jitter random).

3. Bulkhead:          Izolarea resurselor per serviciu/funcție
                      (un serviciu supraîncărcat nu afectează altele).

4. Saga Pattern:      Tranzacții distribuite prin secvență de
                      tranzacții locale + compensări la eșec.

5. CQRS:              Command Query Responsibility Segregation.
                      Scrie în DB normalizată, citește din view optimizat.

6. Event Sourcing:    Stochează TOATE evenimentele (nu starea curentă).
                      Starea = replay-ul tuturor evenimentelor.

7. Sidecar:           Funcționalitate auxiliară într-un container
                      alăturat (logging, proxy, service mesh).

8. Strangler Fig:     Migrare incrementală: noul sistem „înghite"
                      treptat funcționalitățile vechiului sistem.

NETWORKING:
□ VPC cu subrețele public/private/database pe 3+ AZ
□ NAT Gateway per AZ (high availability)
□ Security Groups: least privilege, referințe între SG-uri
□ VPC Flow Logs activate
□ VPC Endpoints pentru servicii AWS (S3, ECR, etc.)
□ Fără SSH/RDP direct (folosește SSM Session Manager)

COMPUTE:
□ Auto Scaling configurat (min/max/desired)
□ Health checks la nivel ALB + aplicație
□ IMDSv2 obligatoriu pe EC2
□ Graviton/ARM acolo unde e posibil (20% mai ieftin)

STOCARE:
□ S3: versioning, encryption, block public access, lifecycle
□ EBS: encryption, backup/snapshot automate

BAZE DE DATE:
□ Multi-AZ (failover automat)
□ Backup automat (min 14 zile retenție)
□ Encryption at rest + in transit
□ Performance Insights activat
□ Credențiale în Secrets Manager (nu hardcodate!)

SECURITATE:
□ IAM roles (nu access keys) pentru servicii
□ MFA pe root account și toți userii IAM
□ CloudTrail activat (toate regiunile)
□ AWS Config rules active
□ GuardDuty activat
□ Criptare everywhere (at rest + in transit)

OBSERVABILITATE:
□ CloudWatch alarms pe metrici critice
□ Logging centralizat
□ Dashboards per serviciu
□ Alertare → PagerDuty / Slack / Email

COST:
□ Tagging pe TOATE resursele
□ AWS Budgets cu alerte
□ Savings Plans / RI pentru workloads stabile
□ Revizuire lunară Compute Optimizer
□ Cleanup resurse orfane (periodic)

DR:
□ Backup cross-region pentru date critice
□ DR plan documentat și TESTAT (cel puțin semestrial)
□ Runbooks pentru scenarii de failure