EXPLAIN ANALYZE
SELECT o.id, o.created_at, u.email
FROM orders o
JOIN users u ON u.id = o.user_id
WHERE o.created_at >= CURRENT_DATE - INTERVAL '30 days'
  AND o.status = 'completed';

->  Hash Join  (cost=19.15..729.45 rows=238 width=80) (actual time=0.432..5.512 rows=245)
      Hash Cond: (o.user_id = u.id)
      ->  Seq Scan on orders o  (cost=0.00..685.20 rows=238 width=56)
            Filter: (status = 'completed') AND (created_at >= (CURRENT_DATE - '30 days'::interval))
      ->  Hash  (cost=12.40..12.40 rows=540 width=36)
            ->  Seq Scan on users u  (cost=0.00..12.40 rows=540 width=36)

CREATE INDEX idx_orders_date_status ON orders(created_at, status);

EXPLAIN ANALYZE SELECT ...
->  Hash Join  (cost=19.15..129.45 rows=238 width=80) (actual time=0.132..0.512 rows=245)
      Hash Cond: (o.user_id = u.id)
      ->  Index Scan using idx_orders_date_status on orders o  (cost=0.00..85.20 rows=238 width=56)
            Filter: (status = 'completed') AND (created_at >= (CURRENT_DATE - '30 days'::interval))
      ->  Hash  (cost=12.40..12.40 rows=540 width=36)
            ->  Seq Scan on users u  (cost=0.00..12.40 rows=540 width=36)

CREATE INDEX idx_users_email ON users(id) INCLUDE (email);

CREATE TABLE transactions_new (
    id bigint,
    created_at timestamp,
    amount decimal,
    -- другие поля
) PARTITION BY RANGE (created_at);

-- Создаем партиции для каждого месяца
CREATE TABLE transactions_2024_01 
PARTITION OF transactions_new 
FOR VALUES FROM ('2024-01-01') TO ('2024-02-01');

-- Функция для переноса данных за один день
CREATE OR REPLACE FUNCTION migrate_day(day_start date) 
RETURNS integer AS $$
BEGIN
    RETURN WITH moved AS (
        DELETE FROM transactions 
        WHERE created_at >= day_start 
        AND created_at < day_start + interval '1 day'
        RETURNING *
    )
    INSERT INTO transactions_new 
    SELECT * FROM moved;
END;
$$ LANGUAGE plpgsql;

-- Запускаем параллельно для разных дней
SELECT migrate_day(day) 
FROM generate_series('2023-01-01'::date, '2024-01-01', '1 day') day;

-- Перемещаем старую партицию на другое табличное пространство
ALTER TABLE transactions_2023_01 
SET TABLESPACE cold_storage;

-- Отключаем автовакуум для старых партиций
ALTER TABLE transactions_2023_01 
SET (autovacuum_enabled = false);

SELECT partman.create_parent(
    'public.transactions',
    'created_at',
    'range',
    'month',
    p_premake := 3
);

ALTER SYSTEM SET synchronous_commit TO 'on';
ALTER SYSTEM SET synchronous_standby_names TO 'replica1';

{w: 1, j: true} // Ждём запись только на primary
{w: 'majority', j: true} // Ждём запись на большинство нод

scope: postgres-cluster
namespace: /db/
name: postgres1

restapi:
  listen: 0.0.0.0:8008
  connect_address: 10.0.0.1:8008

postgresql:
  listen: 0.0.0.0:5432
  connect_address: 10.0.0.1:5432
  data_dir: /data/postgres
  bin_dir: /usr/lib/postgresql/14/bin

  parameters:
    max_connections: 100
    shared_buffers: 4GB
    wal_level: replica
    hot_standby: "on"

-- На реплике первого уровня
primary_conninfo = 'host=10.0.0.1 port=5432'

-- На реплике второго уровня
primary_conninfo = 'host=10.0.0.2 port=5432'

- job_name: 'postgres_exporter'
  static_configs:
    - targets: ['10.0.0.1:9187']
  metrics_path: /metrics
  params:
    query:
      - 'pg_replication_lag'
      - 'pg_wal_activity'

module "web_cluster" {
  source = "git::https://github.com/company/tf-modules.git//web-cluster?ref=v2.3.1"
  
  cluster_name = "prod-web"
  instance_count = 5
  zone_id = "Z2FDTNDATAQYW2"
}

resource "aws_s3_bucket" "terraform_state" {
  bucket = "company-terraform-state"

  versioning {
    enabled = true
  }

  lifecycle_rule {
    enabled = true
    noncurrent_version_expiration {
      days = 90
    }
    abort_incomplete_multipart_upload_days = 7
  }
}

resource "aws_route53_record" "www" {
  zone_id = aws_route53_zone.primary.zone_id
  name    = "www.example.com"
  type    = "A"

  alias {
    name                   = var.environment == "blue" ? aws_lb.blue.dns_name : aws_lb.green.dns_name
    zone_id                = var.environment == "blue" ? aws_lb.blue.zone_id : aws_lb.green.zone_id
    evaluate_target_health = true
  }
}

# network/main.tf
terraform {
  backend "s3" {
    bucket   = "terraform-states"
    key      = "network/terraform.tfstate"
    endpoint = "storage.yandexcloud.net"
  }
}

# databases/main.tf
terraform {
  backend "s3" {
    bucket   = "terraform-states"
    key      = "databases/terraform.tfstate"
    endpoint = "storage.yandexcloud.net"
  }
}

data "terraform_remote_state" "network" {
  backend = "s3"
  config = {
    bucket   = "terraform-states"
    key      = "network/terraform.tfstate"
    endpoint = "storage.yandexcloud.net"
  }
}

resource "yandex_mdb_postgresql_cluster" "postgres" {
  name        = "prod-postgres"
  environment = "PRODUCTION"
  network_id  = data.terraform_remote_state.network.outputs.network_id

  config {
    version = "15"
    resources {
      resource_preset_id = "s3-c2-m8"
      disk_size         = 100
    }
  }
}

terraform {
  backend "s3" {
    bucket     = "terraform-states"
    key        = "secrets/terraform.tfstate"
    endpoint   = "storage.yandexcloud.net"
    kms_key_id = "abjhq8c9gct5pd5klm7p"
    
    access_key = var.storage_access_key
    secret_key = var.storage_secret_key
  }
}

infrastructure/
├── modules/           # Переиспользуемые модули
│   ├── network/      # Базовая сетевая инфраструктура
│   ├── compute/      # Compute ресурсы
│   └── storage/      # Хранилища данных
├── environments/      # Окружения
│   ├── prod/         # Production
│   └── stage/        # Staging
└── platform/         # Платформенные сервисы
    ├── monitoring/   # Мониторинг
    └── security/     # Безопасность

module "test_network" {
  source = "../../modules/network"

  providers = {
    yandex = yandex.testing
  }

  environment = "test"
  subnets = {
    "a" = ["10.0.1.0/24"]
    "b" = ["10.0.2.0/24"]
    "c" = ["10.0.3.0/24"]
  }
}

resource "test_assertions" "network" {
  component = "network"

  check "subnets_created" {
    denoscription = "Проверка создания подсетей"
    condition   = length(module.test_network.subnet_ids) == 3
  }

  check "network_connectivity" {
    denoscription = "Проверка связности подсетей"
    condition   = can(module.test_network.test_connectivity)
  }
}

policy "enforce_mandatory_tags" {
  enforcement_level = "hard-mandatory"
  
  rule "check_tags" {
    source = "./rules/tags.sentinel"
  }
}

import "tfplan/v2" as tfplan

mandatory_tags = ["project", "environment", "owner", "cost-center"]

check_resource_tags = func(resource) {
    tags = resource.change.after.labels
    return all mandatory_tags as tag {
        tags contains tag
    }
}

resource "yandex_monitoring_dashboard" "terraform" {
  name = "terraform-changes"
  
  chart {
    noscript = "Infrastructure Changes"
    
    metrics {
      name = "terraform.apply.success"
      aggregation = "COUNT"
    }
    
    metrics {
      name = "terraform.apply.failure"
      aggregation = "COUNT"
    }
  }

  alert {
    name = "High Rate of Failed Changes"
    condition = "rate(terraform.apply.failure[1h]) > 3"
    severity = "critical"
  }
}