Инфраструктура как код на C#

// Пример определения виртуальной машины с типобезопасностью
var vmConfig = new VirtualMachineConfiguration 
{
    Name = "production-backend",
    Size = VirtualMachineSizes.Standard_D2s_v3,
    OsProfile = new OsProfile 
    {
        ComputerName = "prod-backend-01",
        AdminUsername = "adminuser",
        // Ошибка компиляции если пароль не соответствует требованиям безопасности
        AdminPassword = passwordFromVault 
    }
};

// Декларативное определение ресурса
var storageAccount = new StorageAccount("mystorageacct")
{
    Location = "westeurope",
    Kind = StorageKind.StorageV2,
    Sku = new StorageSku { Name = SkuName.Standard_LRS }
};
 
// Императивная логика применения конфигурации
if (environment == Environments.Production)
{
    storageAccount.EnableHttpsTrafficOnly = true;
    storageAccount.MinimumTlsVersion = "TLS1_2";
    
    // Дополнительная логика для продакшена
    await ConfigureNetworkRulesAsync(storageAccount);
}

// Пример параллельного создания ресурсов в C#
var tasks = resourceDefinitions.Select(async def => {
    try {
        return await resourceClient.CreateResourceAsync(def);
    }
    catch (Exception ex) {
        logger.LogError(ex, $"Failed to create {def.Name}");
        return null;
    }
});
 
var createdResources = await Task.WhenAll(tasks);

[Fact]
public async Task Storage_Account_Should_Be_Private_In_Production()
{
    // Arrange
    var infra = new ProductionInfrastructure();
    
    // Act
    var storageAccount = await infra.ProvisionStorageAccountAsync();
    
    // Assert
    Assert.True(storageAccount.EnableHttpsTrafficOnly);
    Assert.Equal(storageAccount.NetworkRuleSet.DefaultAction, "Deny");
}

// Создание виртуальной сети с помощью Azure SDK
var vnetParams = new VirtualNetwork
{
    Location = "westeurope",
    AddressSpace = new AddressSpace { AddressPrefixes = new List<string> { "10.0.0.0/16" } },
    Subnets = new List<Subnet>
    {
        new Subnet { Name = "default", AddressPrefix = "10.0.0.0/24" }
    }
};
 
var vnet = await networkClient.VirtualNetworks.StartCreateOrUpdateAsync(
    "my-resource-group", 
    "my-vnet", 
    vnetParams
);

// Создание бакета S3 в AWS с помощью Pulumi
var bucket = new Bucket("my-website", new BucketArgs
{
    Website = new BucketWebsiteArgs
    {
        IndexDocument = "index.html"
    },
    Tags = 
    {
        { "Environment", "Production" },
        { "ManagedBy", "Pulumi" }
    }
});
 
// Экспорт URL бакета
return new Dictionary<string, object?>
{
    ["websiteUrl"] = bucket.WebsiteEndpoint
};

var network = new VirtualNetwork("production_network", new VirtualNetworkArgs
{
    ResourceGroupName = resourceGroup.Name,
    AddressSpaces = { "10.0.0.0/16" },
    Location = resourceGroup.Location,
});
 
var subnet = new Subnet("default", new SubnetArgs
{
    ResourceGroupName = resourceGroup.Name,
    VirtualNetworkName = network.Name,
    AddressPrefix = "10.0.1.0/24",
});

// Эффективное параллельное создание множества VM
var creationTasks = new List<Task<ArmOperation<VirtualMachineResource>>>();
 
foreach (var vmConfig in vmConfigurations)
{
    creationTasks.Add(computeClient.VirtualMachines.StartCreateOrUpdateAsync(
        resourceGroup,
        $"vm-{vmConfig.Name}",
        vmConfig.ToVmData()
    ));
}
 
// Ожидаем завершения всех операций
await Task.WhenAll(creationTasks);

[Fact]
public void NetworkConfig_ShouldHave_ProperSecurityRules()
{
    // Arrange
    var networkBuilder = new NetworkConfigurationBuilder();
    
    // Act
    var config = networkBuilder.BuildProductionConfig();
    
    // Assert
    Assert.Contains(config.SecurityRules, rule => 
        rule.Direction == SecurityRuleDirection.Inbound && 
        rule.Access == SecurityRuleAccess.Deny && 
        rule.SourceAddressPrefix == "*" && 
        rule.DestinationPortRange == "22"
    );
}

[Fact]
public async Task StorageAccount_ShouldBe_AccessibleAfterDeployment()
{
    // Arrange
    var deployer = new InfrastructureDeployer();
    string testRg = $"test-rg-{Guid.NewGuid()}";
    
    try
    {
        // Act
        var storageAccount = await deployer.DeployStorageAccountAsync(testRg);
        var blobClient = new BlobClient(storageAccount.ConnectionString, "test", "test.txt");
        
        await blobClient.UploadTextAsync("Hello, World!");
        var downloadedContent = await blobClient.DownloadContentAsync();
        
        // Assert
        Assert.Equal("Hello, World!", downloadedContent.Value.Content.ToString());
    }
    finally
    {
        // Cleanup
        await deployer.CleanupResourceGroupAsync(testRg);
    }
}

var deployment = new AzureDeployment()
    .WithResourceGroup("production-rg")
    .InRegion(Region.WestEurope)
    .AddWebApp(app => app
        .WithName("my-awesome-service")
        .UsingDotNet6()
        .WithScaling(scaling => scaling
            .MinInstances(2)
            .MaxInstances(10)
            .AutoscaleBasedOn(Metric.CpuPercentage, 75))
        .WithCustomDomain("api.mycompany.com"))
    .AddDatabase(db => db
        .SqlServer()
        .WithHighAvailability());

// Расширение базового функционала Pulumi для Azure
public static class AzureResourceExtensions
{
    public static T WithStandardTags<T>(this T resource) where T : CustomResource
    {
        resource.Tags.Add("Environment", Deployment.Instance.StackName);
        resource.Tags.Add("DeployedBy", Environment.UserName);
        resource.Tags.Add("DeploymentDate", DateTime.UtcNow.ToString("o"));
        return resource;
    }
    
    public static T WithComplianceTags<T>(this T resource) where T : CustomResource
    {
        resource.Tags.Add("DataClassification", "Confidential");
        resource.Tags.Add("ComplianceStatus", "GDPR-Compliant");
        return resource;
    }
}

// Получение секретов из Azure Key Vault
var kvClient = new SecretClient(
    new Uri("https://my-keyvault.vault.azure.net/"), 
    new DefaultAzureCredential());
 
// Асинхронное получение секрета для использования
string dbConnectionString = (await kvClient.GetSecretAsync("DatabaseConnection")).Value.Value;
 
// Использование секрета при создании ресурса
var dbConfig = new DatabaseConfiguration 
{
    ConnectionString = dbConnectionString,
    // Другие параметры
};

// Pulumi пример
var dbPassword = new Output<string>("my-super-secret-password").Apply(s => 
{
    // Маркируем как секрет для предотвращения случайного логирования
    return Output.CreateSecret(s);
});

// Чтение и расшифровка секретов из защищенного хранилища
var protectedSettings = File.ReadAllText("protected-settings.json");
var encryptionCert = new X509Certificate2("encryption-cert.pfx", "cert-password");
 
var plainTextSettings = ProtectedData.Unprotect(
    Convert.FromBase64String(protectedSettings),
    null,
    DataProtectionScope.CurrentUser);
 
var settings = JsonSerializer.Deserialize<AppSettings>(
    Encoding.UTF8.GetString(plainTextSettings));

public class AzureDeployer
{
    private readonly ILogger<AzureDeployer> _logger;
    
    public AzureDeployer(ILogger<AzureDeployer> logger)
    {
        _logger = logger;
    }
    
    public async Task DeployResourceAsync(ResourceDefinition definition)
    {
        using (_logger.BeginScope("Deploying {ResourceType} {ResourceName}", 
                                 definition.Type, definition.Name))
        {
            _logger.LogInformation("Starting deployment...");
            
            try
            {
                // Логика развертывания ресурса
                await DeployResourceInternalAsync(definition);
                
                _logger.LogInformation("Deployment completed successfully");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Deployment failed");
                throw;
            }
        }
    }
}

private static readonly ActivitySource _activitySource = 
    new ActivitySource("MyCompany.InfrastructureDeployment");
 
public async Task<DeploymentResult> DeployEnvironmentAsync(EnvironmentDefinition env)
{
    using var activity = _activitySource.StartActivity("DeployEnvironment");
    activity?.SetTag("Environment", env.Name);
    activity?.SetTag("Region", env.Region);
    
    // Параллельное развертывание ресурсов с трассировкой
    var tasks = env.Resources.Select(async resource => 
    {
        using var resourceActivity = _activitySource.StartActivity("DeployResource");
        resourceActivity?.SetTag("ResourceType", resource.Type);
        resourceActivity?.SetTag("ResourceName", resource.Name);
        
        return await DeployResourceAsync(resource);
    });
    
    var results = await Task.WhenAll(tasks);
    
    return new DeploymentResult { /* ... */ };
}

public class WebAppStack : InfrastructureComponent
{
    private readonly WebAppOptions _options;
 
    public WebAppStack(WebAppOptions options)
    {
        _options = options ?? throw new ArgumentNullException(nameof(options));
    }
 
    public override async Task<DeploymentResult> DeployAsync(IDeploymentContext context)
    {
        // Разворачиваем App Service
        var appServicePlan = await DeployAppServicePlanAsync(context);
        var webApp = await DeployWebAppAsync(context, appServicePlan);
        
        // Разворачиваем базу данных если требуется
        if (_options.IncludeDatabase)
        {
            var database = await DeployDatabaseAsync(context);
            await ConfigureConnectionStringAsync(webApp, database);
        }
        
        // Интеграция с CDN если требуется
        if (_options.IncludeCdn)
        {
            var cdn = await DeployCdnAsync(context, webApp);
            await ConfigureCdnAsync(webApp, cdn);
        }
        
        return new DeploymentResult
        {
            Endpoints = new Dictionary<string, string>
            {
                { "WebApp", webApp.DefaultHostName },
                { "SCM", $"https://{webApp.DefaultHostName}/scm" }
            }
        };
    }
    
    // Вспомогательные методы для развертывания компонентов...
}

var webStack = new WebAppStack(new WebAppOptions
{
    Name = "customer-portal",
    Environment = Environments.Production,
    Tier = AppServiceTier.Premium,
    IncludeDatabase = true,
    DatabaseOptions = new DatabaseOptions
    {
        Type = DatabaseType.SqlServer,
        Edition = SqlServerEdition.BusinessCritical,
        Replicas = 1
    },
    IncludeCdn = true
});
 
await webStack.DeployAsync(deploymentContext);

// Пример настройки условного доступа к ресурсам на основе RBAC
public async Task<IEnumerable<SubscriptionResource>> GetAuthorizedSubscriptionsAsync()
{
    var armClient = new ArmClient(new DefaultAzureCredential());
    var allSubscriptions = await armClient.GetSubscriptions().GetAllAsync().ToListAsync();
    
    var authorizedSubscriptions = new List<SubscriptionResource>();
    
    foreach (var subscription in allSubscriptions)
    {
        // Проверяем права на подписку
        try
        {
            var authResult = await subscription.GetAuthorizationAsync(
                "Microsoft.Resources/subscriptions/resourceGroups/write");
            
            if (authResult.Status == AuthorizationStatus.Allowed)
            {
                authorizedSubscriptions.Add(subscription);
            }
        }
        catch (RequestFailedException)
        {
            // Нет доступа к подписке, пропускаем
            continue;
        }
    }
    
    return authorizedSubscriptions;
}

// Контроллер для запуска создания тестовых сред из пайплайна
[ApiController]
[Route("api/environments")]
public class EnvironmentsController : ControllerBase
{
    private readonly IEnvironmentManager _environmentManager;
    
    public EnvironmentsController(IEnvironmentManager environmentManager)
    {
        _environmentManager = environmentManager;
    }
    
    [HttpPost("feature")]
    public async Task<IActionResult> CreateFeatureEnvironment(CreateFeatureEnvironmentRequest request)
    {
        var environment = await _environmentManager.CreateFeatureEnvironmentAsync(
            request.FeatureId, 
            request.BranchName,
            request.CommitId);
            
        return Ok(new { 
            EnvironmentId = environment.Id,
            Url = environment.BaseUrl,
            ProvisioningLogs = environment.ProvisioningLogs
        });
    }
    
    [HttpDelete("{environmentId}")]
    public async Task<IActionResult> DeleteEnvironment(string environmentId)
    {
        await _environmentManager.DeleteEnvironmentAsync(environmentId);
        return NoContent();
    }
}

public class FileSystemStateManager : IStateManager
{
    private readonly string _statePath;
    
    public FileSystemStateManager(string statePath)
    {
        _statePath = statePath;
        Directory.CreateDirectory(Path.GetDirectoryName(statePath)!);
    }
    
    public async Task<InfrastructureState> LoadStateAsync()
    {
        if (!File.Exists(_statePath))
        {
            return new InfrastructureState();
        }
        
        var json = await File.ReadAllTextAsync(_statePath);
        return JsonSerializer.Deserialize<InfrastructureState>(json) 
               ?? new InfrastructureState();
    }
    
    public async Task SaveStateAsync(InfrastructureState state)
    {
        var json = JsonSerializer.Serialize(state, new JsonSerializerOptions
        {
            WriteIndented = true,
            Converters = { new JsonStringEnumConverter() }
        });
        
        await File.WriteAllTextAsync(_statePath, json);
    }
}

public class AzureTableStateManager : IStateManager
{
    private readonly TableClient _tableClient;
    private const string PartitionKey = "InfrastructureState";
    
    public AzureTableStateManager(string connectionString, string tableName)
    {
        _tableClient = new TableClient(connectionString, tableName);
        _tableClient.CreateIfNotExists();
    }
    
    public async Task<InfrastructureState> LoadStateAsync()
    {
        try
        {
            var response = await _tableClient.GetEntityAsync<StateEntity>(
                PartitionKey, 
                Environment.GetEnvironmentVariable("DEPLOYMENT_ENVIRONMENT") ?? "default");
                
            return JsonSerializer.Deserialize<InfrastructureState>(
                response.Value.StateJson) ?? new InfrastructureState();
        }
        catch (RequestFailedException ex) when (ex.Status == 404)
        {
            return new InfrastructureState();
        }
    }
    
    public async Task SaveStateAsync(InfrastructureState state)
    {
        var entity = new StateEntity
        {
            PartitionKey = PartitionKey,
            RowKey = Environment.GetEnvironmentVariable("DEPLOYMENT_ENVIRONMENT") ?? "default",
            StateJson = JsonSerializer.Serialize(state),
            LastUpdated = DateTime.UtcNow
        };
        
        await _tableClient.UpsertEntityAsync(entity);
    }
    
    private class StateEntity : ITableEntity
    {
        public string PartitionKey { get; set; } = string.Empty;
        public string RowKey { get; set; } = string.Empty;
        public string StateJson { get; set; } = "{}";
        public DateTime LastUpdated { get; set; }
        public ETag ETag { get; set; } = ETag.All;
        public DateTimeOffset? Timestamp { get; set; }
    }
}

public static class ResourceVersioning
{
  public static T WithVersionMetadata<T>(this T resource, string version) 
      where T : IHasTags
  {
      resource.Tags ??= new Dictionary<string, string>();
      resource.Tags["Version"] = version;
      resource.Tags["DeploymentId"] = Guid.NewGuid().ToString();
      resource.Tags["DeploymentTimestamp"] = DateTime.UtcNow.ToString("o");
      
      return resource;
  }
  
  public static async Task<Dictionary<string, string>> GetResourceVersionHistoryAsync(
      this ArmClient client, ResourceIdentifier resourceId)
  {
      var resource = await client.GetGenericResource(resourceId).GetAsync();
      var tags = resource.Data.Tags;
      
      // Здесь можно добавить логику получения истории из специального хранилища
      
      return tags;
  }
}

public interface ICloudResourceFactory
{
  IVirtualMachine CreateVirtualMachine(VmOptions options);
  IDatabase CreateDatabase(DatabaseOptions options);
  ILoadBalancer CreateLoadBalancer(LoadBalancerOptions options);
}
 
public class AzureResourceFactory : ICloudResourceFactory 
{
  public IVirtualMachine CreateVirtualMachine(VmOptions options) 
      => new AzureVirtualMachine(options);
  
  public IDatabase CreateDatabase(DatabaseOptions options) 
      => new AzureSqlDatabase(options);
  
  public ILoadBalancer CreateLoadBalancer(LoadBalancerOptions options) 
      => new AzureLoadBalancer(options);
}
 
public class AwsResourceFactory : ICloudResourceFactory 
{
  public IVirtualMachine CreateVirtualMachine(VmOptions options) 
      => new Ec2Instance(options);
  
  public IDatabase CreateDatabase(DatabaseOptions options) 
      => new RdsDatabase(options);
  
  public ILoadBalancer CreateLoadBalancer(LoadBalancerOptions options) 
      => new ElasticLoadBalancer(options);
}

public interface IDeploymentStrategy
{
  Task<DeploymentResult> DeployAsync(InfrastructureStack stack);
}
 
public class BlueGreenDeploymentStrategy : IDeploymentStrategy
{
  public async Task<DeploymentResult> DeployAsync(InfrastructureStack stack)
  {
      // Создаём копию инфраструктуры
      var greenStack = await CreateCopyOfInfrastructureAsync(stack);
      
      // Развёртываем новую версию на зелёной среде
      await DeployToStackAsync(greenStack);
      
      // Проводим тесты
      var testResult = await RunSmokeTestsAsync(greenStack);
      
      if (testResult.Success)
      {
          // Переключаем трафик на новую среду
          await SwitchTrafficAsync(stack, greenStack);
          return new DeploymentResult { Success = true };
      }
      
      // Откат при проблемах
      await DeleteStackAsync(greenStack);
      return new DeploymentResult { Success = false };
  }
}

public class LocalDevEnvironment
{
    public async Task SetupAsync()
    {
        // Развёртывание локальных контейнеров
        var dockerClient = new DockerClientConfiguration()
            .CreateClient();
 
        // SQL Server в контейнере
        var sqlContainer = await dockerClient.Containers.CreateContainerAsync(
            new CreateContainerParameters
            {
                Image = "mcr.microsoft.com/mssql/server:2019-latest",
                Name = "dev-sql",
                HostConfig = new HostConfig
                {
                    PortBindings = new Dictionary<string, IList<PortBinding>>
                    {
                        { "1433/tcp", new List<PortBinding> { new PortBinding { HostPort = "14330" } } }
                    }
                },
                Env = new List<string>
                {
                    "ACCEPT_EULA=Y",
                    "SA_PASSWORD=DevPassword!123"
                }
            });
 
        await dockerClient.Containers.StartContainerAsync("dev-sql", null);
 
        // Эмулятор Azure Storage
        await dockerClient.Containers.CreateContainerAsync(
            new CreateContainerParameters
            {
                Image = "mcr.microsoft.com/azure-storage/azurite",
                Name = "dev-storage",
                HostConfig = new HostConfig
                {
                    PortBindings = new Dictionary<string, IList<PortBinding>>
                    {
                        { "10000/tcp", new List<PortBinding> { new PortBinding { HostPort = "10000" } } },
                        { "10001/tcp", new List<PortBinding> { new PortBinding { HostPort = "10001" } } },
                        { "10002/tcp", new List<PortBinding> { new PortBinding { HostPort = "10002" } } }
                    }
                }
            });
 
        await dockerClient.Containers.StartContainerAsync("dev-storage", null);
 
        // Конфигурация локального приложения
        await ConfigureLocalAppSettingsAsync();
    }
 
    private async Task ConfigureLocalAppSettingsAsync()
    {
        var appSettings = new JObject
        {
            ["ConnectionStrings"] = new JObject
            {
                ["DefaultConnection"] = "Server=localhost,14330;Database=DevDB;User=sa;Password=DevPassword!123;TrustServerCertificate=True"
            },
            ["Storage"] = new JObject
            {
                ["ConnectionString"] = "UseDevelopmentStorage=true"
            }
        };
 
        await File.WriteAllTextAsync("appsettings.Development.json", appSettings.ToString());
    }
}

public class InfrastructureValidator
{
    private readonly ILogger<InfrastructureValidator> _logger;
 
    public InfrastructureValidator(ILogger<InfrastructureValidator> logger)
    {
        _logger = logger;
    }
 
    public async Task<ValidationResult> ValidateChangesAsync(
        InfrastructureDefinition planned,
        InfrastructureDefinition current)
    {
        var result = new ValidationResult();
 
        // 1. Проверка безопасных изменений
        foreach (var change in DetectChanges(current, planned))
        {
            if (IsDestructiveChange(change))
            {
                result.Warnings.Add($"Потенциально деструктивное изменение: {change.Description}");
            }
        }
 
        // 2. Проверка на соответствие корпоративным политикам
        var policyViolations = await CheckCorporatePolicyAsync(planned);
        result.PolicyViolations.AddRange(policyViolations);
 
        // 3. Оценка стоимости
        result.EstimatedCost = await CalculateEstimatedCostAsync(planned);
        
        // Здесь могут быть и другие проверки...
 
        return result;
    }
 
    private bool IsDestructiveChange(ResourceChange change)
    {
        // Проверка на удаление или изменение критических свойств
        return change.ChangeType == ChangeType.Delete || 
               (change.ChangeType == ChangeType.Update && 
                change.ChangedProperties.Any(p => p.IsCritical));
    }
}

public class ResilientResourceProvisioner
{
    private readonly ILogger _logger;
    
    public async Task<TResource> ProvisionWithRetryAsync<TResource>(
        Func<Task<TResource>> provisionFunc, 
        int maxAttempts = 3)
    {
        var retryPolicy = Policy
            .Handle<RequestFailedException>(ex => ex.Status == 429 || 
                                            (ex.Status >= 500 && ex.Status < 600))
            .WaitAndRetryAsync(
                maxAttempts, 
                retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
                (exception, timeSpan, context) => 
                {
                    _logger.LogWarning(exception, 
                        "Ошибка при создании ресурса. Повтор через {RetryTimeSpan}", 
                        timeSpan);
                }
            );
 
        return await retryPolicy.ExecuteAsync(provisionFunc);
    }
}

public class MessageProcessingInfrastructure
{
    private readonly ArmClient _armClient;
    private readonly string _resourceGroup;
    private readonly string _baseName;
    private readonly Region _region;
 
    public MessageProcessingInfrastructure(ArmClient armClient, string resourceGroup, 
                                          string baseName, Region region)
    {
        _armClient = armClient;
        _resourceGroup = resourceGroup;
        _baseName = baseName;
        _region = region;
    }
 
    public async Task<MessageInfrastructureResult> DeployAsync()
    {
        // Получаем группу ресурсов
        var rgResource = await GetOrCreateResourceGroupAsync();
 
        // Параллельно развёртываем хранилище и план службы
        var storageTask = CreateStorageAccountAsync(rgResource);
        var planTask = CreateFunctionAppPlanAsync(rgResource);
 
        await Task.WhenAll(storageTask, planTask);
        
        var storage = await storageTask;
        var plan = await planTask;
 
        // Создаём Function App
        var functionApp = await CreateFunctionAppAsync(rgResource, storage, plan);
 
        // Настраиваем очереди для обработки сообщений
        var queues = await ConfigureQueuesAsync(storage);
 
        return new MessageInfrastructureResult
        {
            FunctionAppHostName = functionApp.Data.DefaultHostName,
            StorageConnectionString = await GetStorageConnectionStringAsync(storage),
            InputQueueName = queues.InputQueue,
            OutputQueueName = queues.OutputQueue
        };
    }
 
    private async Task<ResourceGroupResource> GetOrCreateResourceGroupAsync()
    {
        var sub = await _armClient.GetDefaultSubscriptionAsync();
        var rgCollection = sub.GetResourceGroups();
        
        if (await rgCollection.ExistsAsync(_resourceGroup))
        {
            return await rgCollection.GetAsync(_resourceGroup);
        }
        
        return await rgCollection.CreateOrUpdateAsync(
            WaitUntil.Completed,
            _resourceGroup,
            new ResourceGroupData(_region)
        );
    }
 
    // Другие вспомогательные методы...
}

public class InfrastructureMonitor
{
    private readonly TelemetryClient _telemetryClient;
    private readonly ArmClient _armClient;
 
    public InfrastructureMonitor(TelemetryClient telemetryClient, ArmClient armClient)
    {
        _telemetryClient = telemetryClient;
        _armClient = armClient;
    }
 
    public async Task<InfrastructureHealthReport> MonitorResourcesAsync(
        IEnumerable<ResourceIdentifier> resourceIds)
    {
        var report = new InfrastructureHealthReport();
        
        foreach (var resourceId in resourceIds)
        {
            try
            {
                var resource = await _armClient.GetGenericResource(resourceId).GetAsync();
                var metrics = await CollectResourceMetricsAsync(resourceId);
                
                report.ResourceStatuses.Add(new ResourceStatus
                {
                    ResourceId = resourceId.ToString(),
                    State = resource.Data.ProvisioningState,
                    Metrics = metrics,
                    LastChecked = DateTime.UtcNow
                });
                
                // Отправка телеметрии для долгосрочного анализа
                _telemetryClient.TrackMetric(
                    $"Resource_{resource.Data.ResourceType.Replace('/', '_')}_Status",
                    resource.Data.ProvisioningState == "Succeeded" ? 1 : 0);
            }
            catch (Exception ex)
            {
                report.Errors.Add(new ResourceMonitoringError
                {
                    ResourceId = resourceId.ToString(),
                    Error = ex.Message
                });
            }
        }
        
        return report;
    }
}

public interface ICloudStorageProvider
{
    Task<string> CreateBlobContainerAsync(string name);
    Task UploadBlobAsync(string containerName, string blobName, Stream content);
    Task<Stream> DownloadBlobAsync(string containerName, string blobName);
}
 
public class AzureStorageProvider : ICloudStorageProvider
{
    private readonly BlobServiceClient _blobServiceClient;
    
    // Реализация для Azure
}
 
public class AwsStorageProvider : ICloudStorageProvider
{
    private readonly AmazonS3Client _s3Client;
    
    // Реализация для AWS
}
 
// Использование абстракции в коде инфраструктуры
public class MultiCloudFileProcessor
{
    private readonly ICloudStorageProvider _storageProvider;
    
    public MultiCloudFileProcessor(ICloudStorageProvider storageProvider)
    {
        _storageProvider = storageProvider;
    }
    
    public async Task ProcessFileAsync(string containeName, string fileName)
    {
        // Код работает одинаково независимо от провайдера
    }
}