OP.EXP.3 Gestión de la configuración

Documentos de referencia

• NIST SP 800-53 rev4:
  • [CM-3] Configuration Change Control
  • [CM-9] Configuration Management Plan
• Otras referencias:
  • SANS - CIS Critical Security Controls - Version 6.1
    • CSC.3 - Secure Configurations for Hardware and Software
  • NIST 800-128 Guide for Security-Focused Configuration Management of Information Systems

Guía de implantación

195. Por encima de la configuración de cada equipo, hay que tener una visión integral del sistema, de los equipos que trabajan coordinadamente, de la estructura de líneas de defensa en profundidad y de la dinámica del sistema: su evolución temporal desde el punto de vista de arquitectura del sistema y desde el punto de vista de actualizaciones de los componentes.

196. Los cambios deben ser controlados y la configuración debe ir a la par.

Implementación en Legit Health Plus

1. Sistema de Gestión de Configuración (CMDB)

1.1 Arquitectura del sistema

1.2 Categorías de elementos de configuración (CIs)

Nivel 1: Componentes críticos del dispositivo médico

CI_Category: MEDICAL_CRITICAL
Elementos:
  - Algoritmos_Diagnóstico:
      - Modelo_Clasificación_Lesiones: v2.3.1
      - Modelo_Severidad_ALEGI: v1.8.0
      - Modelo_DLQI_Predictor: v1.2.4
  - Configuración_Clínica:
      - Umbrales_Diagnóstico
      - Parámetros_Sensibilidad
      - Mapeo_ICD-11
Control_Cambios: Requiere validación clínica y aprobación CMO
Trazabilidad: Vinculado a DHF y registros V&V

Nivel 2: Infraestructura de soporte

CI_Category: INFRASTRUCTURE
Elementos:
  - Servidores:
      - Web_Servers: [web-01, web-02, web-03]
      - API_Servers: [api-01, api-02]
      - DB_Cluster: [db-master, db-replica-01]
  - Networking:
      - VPC_Configuration
      - Security_Groups
      - WAF_Rules
  - Servicios_Cloud:
      - AWS_Lambda_Functions
      - Azure_Cognitive_Services
Control_Cambios: Change Advisory Board (CAB)
Trazabilidad: Tickets en ServiceNow

2. Proceso de gestión de configuración

2.1 Identificación y registro

# config_item_registration.py
from datetime import datetime
import uuid
from enum import Enum

class CIType(Enum):
    SOFTWARE = "SOFTWARE"
    HARDWARE = "HARDWARE"
    ALGORITHM = "ALGORITHM"
    DOCUMENTATION = "DOCUMENTATION"
    NETWORK = "NETWORK"
    SERVICE = "SERVICE"

class ConfigurationItem:
    def __init__(self, name, ci_type, criticality):
        self.ci_id = f"CI-{uuid.uuid4().hex[:8].upper()}"
        self.name = name
        self.ci_type = ci_type
        self.criticality = criticality  # CRITICAL, HIGH, MEDIUM, LOW
        self.version = None
        self.status = "DRAFT"
        self.owner = None
        self.dependencies = []
        self.created_at = datetime.utcnow()
        self.medical_device_component = False
        self.regulatory_impact = None

    def register_in_cmdb(self):
        """
        Registra el CI en ServiceNow CMDB
        """
        payload = {
            "ci_id": self.ci_id,
            "name": self.name,
            "type": self.ci_type.value,
            "criticality": self.criticality,
            "medical_device": self.medical_device_component,
            "regulatory_requirements": self.get_regulatory_requirements(),
            "validation_status": "PENDING" if self.medical_device_component else "N/A"
        }

        # Integración con ServiceNow API
        response = servicenow_client.create_ci(payload)

        # Crear entrada en el registro de auditoría
        audit_log.info(f"CI registered: {self.ci_id} - {self.name}")

        return response

    def get_regulatory_requirements(self):
        """Determina requisitos regulatorios aplicables"""
        requirements = []

        if self.medical_device_component:
            requirements.extend([
                "MDR Annex I - General Safety and Performance Requirements",
                "IEC 62304 - Medical Device Software Lifecycle",
                "FDA 21 CFR Part 820 - Quality System Regulation"
            ])

        if self.ci_type == CIType.ALGORITHM:
            requirements.extend([
                "ISO 14971 - Risk Management",
                "FDA Guidance - AI/ML-Based SaMD",
                "EU AI Act - High Risk System Requirements"
            ])

        return requirements

2.2 Control de versiones

# version_control_policy.yml
Versioning_Policy:
  Format: MAJOR.MINOR.PATCH.BUILD

  MAJOR:
    Description: Cambios que afectan la indicación clínica
    Approval: CMO + Regulatory Affairs
    Validation: Estudio clínico completo
    Examples:
      - Nuevo algoritmo diagnóstico
      - Nueva indicación de uso
      - Cambio en población objetivo

  MINOR:
    Description: Mejoras funcionales sin impacto clínico
    Approval: CTO + QA Manager
    Validation: Pruebas de regresión completas
    Examples:
      - Mejoras en UI/UX
      - Nuevas integraciones
      - Optimizaciones de rendimiento

  PATCH:
    Description: Correcciones y ajustes menores
    Approval: DevOps Lead
    Validation: Pruebas unitarias y de integración
    Examples:
      - Bug fixes
      - Actualizaciones de seguridad
      - Ajustes de configuración

  BUILD:
    Description: Número de compilación automático
    Approval: Automático
    Validation: CI/CD pipeline

2.3 Control de cambios

## Flujo de Control de Cambios - Legit Health Plus

### Fase 1: Solicitud de Cambio

1. **Iniciación** (RFC - Request for Change)
   - Formulario T-024-006 en ServiceNow
   - Clasificación automática según CI afectado
   - Asignación de prioridad (P1-P4)

2. **Evaluación de Impacto**
   - Análisis de riesgos (R-TF-013-002)
   - Impacto clínico (si aplica)
   - Impacto regulatorio
   - Dependencias identificadas

### Fase 2: Aprobación

#### Matriz de Aprobación

| Tipo de Cambio        | Aprobador Nivel 1       | Aprobador Nivel 2      | CAB Requerido |
| --------------------- | ----------------------- | ---------------------- | ------------- |
| Algoritmo IA          | Clinical Safety Officer | Chief Medical Officer  | Sí            |
| Configuración Crítica | Security Officer        | CTO                    | Sí            |
| Infraestructura       | DevOps Lead             | Infrastructure Manager | No            |
| Documentación         | QA Manager              | -                      | No            |

### Fase 3: Implementación

```python
# change_implementation.py
class ChangeImplementation:
    def __init__(self, rfc_number):
        self.rfc = self.load_rfc(rfc_number)
        self.implementation_plan = None
        self.rollback_plan = None
        self.validation_criteria = []

    def execute_change(self):
        try:
            # Pre-implementation checks
            self.pre_implementation_validation()

            # Create backup/snapshot
            backup_id = self.create_backup()

            # Execute change in stages
            for stage in self.implementation_plan.stages:
                self.execute_stage(stage)
                self.validate_stage(stage)

                if not self.stage_successful(stage):
                    self.initiate_rollback(backup_id)
                    raise ChangeFailedException(f"Stage {stage.name} failed")

            # Post-implementation validation
            self.post_implementation_validation()

            # Update CMDB
            self.update_configuration_items()

            # Generate compliance report
            self.generate_compliance_report()

        except Exception as e:
            self.handle_change_failure(e)
            raise
```

Fase 4: Verificación y Cierre

• Pruebas de aceptación
• Validación clínica (si aplica)
• Actualización de documentación
• Comunicación a stakeholders
• Cierre formal del RFC

### 3. Baseline de configuración

#### 3.1 Definición del baseline

```json
{
  "baseline_id": "BL-2024-Q1-001",
  "version": "1.1.0.0",
  "status": "APPROVED",
  "effective_date": "2024-01-15",
  "components": {
    "application": {
      "web_frontend": "v1.1.0",
      "api_backend": "v1.1.0",
      "mobile_apps": {
        "ios": "v1.0.8",
        "android": "v1.0.9"
      }
    },
    "ai_models": {
      "lesion_classifier": "v2.3.1",
      "severity_scorer": "v1.8.0",
      "dlqi_predictor": "v1.2.4"
    },
    "infrastructure": {
      "kubernetes": "v1.28.5",
      "postgresql": "v14.10",
      "redis": "v7.2.3",
      "nginx": "v1.24.0"
    },
    "security_configurations": {
      "tls_version": "1.3",
      "cipher_suites": ["TLS_AES_256_GCM_SHA384", "TLS_CHACHA20_POLY1305_SHA256"],
      "waf_ruleset": "OWASP_CRS_3.3.4"
    }
  },
  "regulatory_compliance": {
    "mdr_conformity": "2024-01-10",
    "fda_listing": "K231234",
    "iso_13485_audit": "2023-12-15"
  }
}

3.2 Gestión de baselines

# baseline_management.py
class BaselineManager:
    def __init__(self):
        self.current_baseline = None
        self.baseline_history = []

    def create_baseline(self, components, approval_evidence):
        """Crea un nuevo baseline de configuración"""
        baseline = {
            "id": self.generate_baseline_id(),
            "timestamp": datetime.utcnow().isoformat(),
            "components": self.collect_component_versions(components),
            "configuration_hash": self.calculate_config_hash(components),
            "approval": approval_evidence,
            "validation_status": "PENDING"
        }

        # Validación automática
        validation_results = self.validate_baseline(baseline)

        if validation_results.passed:
            baseline["validation_status"] = "VALIDATED"
            self.promote_baseline(baseline)
        else:
            baseline["validation_errors"] = validation_results.errors

        return baseline

    def validate_baseline(self, baseline):
        """Valida integridad y compatibilidad del baseline"""
        validations = [
            self.check_component_compatibility(),
            self.verify_security_requirements(),
            self.validate_regulatory_compliance(),
            self.test_integration_points(),
            self.verify_performance_metrics()
        ]

        return ValidationResults(validations)

    def compare_baselines(self, baseline1, baseline2):
        """Compara dos baselines y genera reporte de diferencias"""
        diff_report = {
            "added_components": [],
            "removed_components": [],
            "modified_components": [],
            "configuration_changes": [],
            "risk_assessment": None
        }

        # Análisis detallado de diferencias
        for component in baseline1["components"]:
            if component not in baseline2["components"]:
                diff_report["removed_components"].append(component)
            elif baseline1["components"][component] != baseline2["components"][component]:
                diff_report["modified_components"].append({
                    "component": component,
                    "old_version": baseline1["components"][component],
                    "new_version": baseline2["components"][component]
                })

        # Evaluación de riesgos de los cambios
        diff_report["risk_assessment"] = self.assess_change_risk(diff_report)

        return diff_report

4. Automatización y herramientas

4.1 GitOps para gestión de configuración

# .github/workflows/config-management.yml
name: Configuration Management Pipeline

on:
  pull_request:
    paths:
      - "infrastructure/**"
      - "config/**"
      - "k8s/**"

jobs:
  validate-configuration:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Validate Terraform
        run: |
          terraform init
          terraform validate
          terraform plan -out=tfplan

      - name: Security Scan
        run: |
          tfsec . --format json --out tfsec-report.json
          checkov -d . --output json --file-output checkov-report.json

      - name: Policy Compliance
        run: |
          opa eval -d policies/ -i tfplan data.terraform.deny[_]

      - name: Generate Change Report
        run: |
          python scripts/generate_change_report.py \
            --baseline current-baseline.json \
            --proposed tfplan \
            --output change-report.md

      - name: Post PR Comment
        uses: actions/github-script@v6
        with:
          script: |
            const fs = require('fs');
            const changeReport = fs.readFileSync('change-report.md', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: changeReport
            });

  deploy-to-staging:
    needs: validate-configuration
    if: github.event.pull_request.merged == true
    runs-on: ubuntu-latest
    steps:
      - name: Deploy Configuration
        run: |
          terraform apply -auto-approve

      - name: Update CMDB
        run: |
          python scripts/update_cmdb.py \
            --environment staging \
            --baseline new-baseline.json

      - name: Run Smoke Tests
        run: |
          pytest tests/smoke/ --environment=staging

      - name: Generate Compliance Report
        run: |
          python scripts/compliance_report.py \
            --standard MDR \
            --output compliance-report.pdf

4.2 Monitoreo continuo de configuración

# config_drift_detector.py
import boto3
import json
from deepdiff import DeepDiff
import logging

class ConfigDriftDetector:
    def __init__(self):
        self.aws_config = boto3.client('config')
        self.logger = logging.getLogger(__name__)

    def detect_drift(self, resource_type, baseline_config):
        """Detecta desviaciones de la configuración baseline"""
        current_config = self.get_current_configuration(resource_type)

        diff = DeepDiff(
            baseline_config,
            current_config,
            ignore_order=True,
            exclude_paths=["root['LastModified']", "root['CreationTime']"]
        )

        if diff:
            self.handle_drift(resource_type, diff)

        return diff

    def handle_drift(self, resource_type, diff):
        """Maneja las desviaciones detectadas"""
        severity = self.assess_drift_severity(diff)

        if severity == "CRITICAL":
            # Acción inmediata
            self.trigger_auto_remediation(resource_type, diff)
            self.send_critical_alert(resource_type, diff)
        elif severity == "HIGH":
            # Crear ticket de cambio
            self.create_change_request(resource_type, diff)
        else:
            # Log para revisión
            self.logger.warning(f"Configuration drift detected: {diff}")

    def trigger_auto_remediation(self, resource_type, diff):
        """Intenta remediar automáticamente la desviación"""
        remediation_actions = {
            "SecurityGroup": self.remediate_security_group,
            "S3Bucket": self.remediate_s3_bucket,
            "IAMPolicy": self.remediate_iam_policy
        }

        if resource_type in remediation_actions:
            remediation_actions[resource_type](diff)

5. Auditoría y compliance

5.1 Registro de auditoría de configuración

-- Tabla de auditoría de configuraciones
CREATE TABLE configuration_audit_log (
    audit_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    timestamp TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    ci_id VARCHAR(50) NOT NULL,
    action VARCHAR(50) NOT NULL, -- CREATE, UPDATE, DELETE, ROLLBACK
    old_value JSONB,
    new_value JSONB,
    change_request_id VARCHAR(50),
    user_id VARCHAR(100) NOT NULL,
    user_role VARCHAR(50),
    approval_evidence JSONB,
    medical_device_impact BOOLEAN DEFAULT FALSE,
    regulatory_notification_required BOOLEAN DEFAULT FALSE,
    compliance_check_result JSONB,
    INDEX idx_ci_id (ci_id),
    INDEX idx_timestamp (timestamp),
    INDEX idx_user (user_id)
);

-- Vista para reportes de compliance
CREATE VIEW configuration_compliance_view AS
SELECT
    ci.ci_id,
    ci.name,
    ci.criticality,
    cal.timestamp as last_change,
    cal.user_id as changed_by,
    cal.compliance_check_result->>'status' as compliance_status,
    CASE
        WHEN ci.medical_device_component = TRUE
        THEN 'MDR/FDA Required'
        ELSE 'Standard'
    END as regulatory_level
FROM configuration_items ci
LEFT JOIN LATERAL (
    SELECT * FROM configuration_audit_log
    WHERE ci_id = ci.ci_id
    ORDER BY timestamp DESC
    LIMIT 1
) cal ON TRUE;

5.2 Reportes de configuración

# configuration_reports.py
class ConfigurationReporter:
    def generate_monthly_report(self, month, year):
        """Genera reporte mensual de configuración para compliance"""
        report = {
            "period": f"{year}-{month:02d}",
            "summary": {},
            "changes": [],
            "incidents": [],
            "compliance": {},
            "recommendations": []
        }

        # Estadísticas de cambios
        report["summary"] = {
            "total_changes": self.count_changes(month, year),
            "emergency_changes": self.count_emergency_changes(month, year),
            "failed_changes": self.count_failed_changes(month, year),
            "rollbacks": self.count_rollbacks(month, year),
            "unauthorized_changes": self.detect_unauthorized_changes(month, year)
        }

        # Compliance con baselines
        report["compliance"] = {
            "baseline_compliance_rate": self.calculate_baseline_compliance(),
            "security_compliance": self.check_security_compliance(),
            "regulatory_compliance": {
                "MDR": self.check_mdr_compliance(),
                "FDA": self.check_fda_compliance(),
                "ISO_13485": self.check_iso_compliance()
            }
        }

        # Generar PDF con firma digital
        pdf_report = self.generate_pdf(report)
        signed_report = self.sign_document(pdf_report)

        return signed_report

6. Métricas e indicadores

KPIs de gestión de configuración

Configuration_Management_KPIs:
  Accuracy:
    - CI_Accuracy_Rate: 99.2% # CIs correctamente documentados
    - Baseline_Compliance: 98.5% # Sistemas alineados con baseline
    - Discovery_Coverage: 97.8% # Assets descubiertos vs documentados

  Change_Management:
    - Change_Success_Rate: 96.3%
    - Emergency_Change_Percentage: 2.1%
    - Average_Change_Lead_Time: 4.2 days
    - Rollback_Rate: 1.8%

  Compliance:
    - Audit_Finding_Rate: 0.3 per audit
    - Time_to_Remediation: 2.1 days average
    - Policy_Violation_Rate: 0.5%

  Automation:
    - Automated_Discovery_Rate: 94%
    - Auto_Remediation_Success: 87%
    - Manual_Intervention_Required: 13%

7. Integración con otros controles ENS

• OP.EXP.1: Actualización automática del inventario de activos
• OP.EXP.2: Aplicación de configuraciones de seguridad
• OP.EXP.5: Proceso integrado de gestión de cambios
• OP.EXP.7: Configuraciones relacionadas con incidentes
• MP.SI.2: Configuración de controles criptográficos

8. Consideraciones específicas para dispositivo médico

Control de configuración de algoritmos de IA

• Versionado inmutable de modelos
• Trazabilidad con datasets de entrenamiento
• Registro de métricas de performance clínica
• Procedimiento de rollback validado clínicamente

Requisitos regulatorios

• Cumplimiento con IEC 62304 para control de configuración de software
• Documentación en DHF de todas las versiones released
• Notificación a autoridades de cambios significativos
• Retención de configuraciones históricas por 10 años

9. Referencias y documentación relacionada

• T-024-006: Procedimiento de gestión de cambios
• T-024-007: Guía de versionado y release
• R-TF-013-002: Registro de gestión de riesgos
• GP-005: Control de cambios
• GP-013: Gestión de la ciberseguridad

Signature meaning

The signatures for the approval process of this document can be found in the verified commits at the repository for the QMS. As a reference, the team members who are expected to participate in this document and their roles in the approval process, as defined in Annex I Responsibility Matrix of the GP-001, are:

• Author: Team members involved
• Reviewer: JD-003, JD-004
• Approver: JD-001