Introdução ao Azure Integration Services: O que é iPaaS e por que sua empresa precisa disso?

graph TB
    AIS[Azure Integration Services]
    AIS --> LA[Logic Apps]
    AIS --> SB[Service Bus]
    AIS --> AM[API Management]
    AIS --> EG[Event Grid]
    AIS --> AF[Azure Functions]
    
    LA --> |Orquestração| Workflows
    SB --> |Mensageria| Queues
    AM --> |Gateway| APIs
    EG --> |Eventos| Reactive
    AF --> |Processamento| Serverless

{
  "definition": {
    "$schema": "https://schema.management.azure.com/schemas/2016-06-01/workflowdefinition.json#",
    "triggers": {
      "when_email_received": {
        "type": "ApiConnection",
        "inputs": {
          "host": {
            "connection": {
              "name": "@parameters('$connections')['outlook']['connectionId']"
            }
          },
          "method": "get",
          "path": "/v2/MailSubscription"
        }
      }
    },
    "actions": {
      "parse_email_content": {
        "type": "ParseJson",
        "inputs": {
          "content": "@triggerBody()?['body']",
          "schema": {
            "type": "object",
            "properties": {
              "requestType": {"type": "string"},
              "amount": {"type": "number"},
              "department": {"type": "string"}
            }
          }
        }
      },
      "check_approval_required": {
        "type": "If",
        "expression": {
          "greater": ["@body('parse_email_content')?['amount']", 1000]
        },
        "actions": {
          "send_approval_request": {
            "type": "ApiConnection",
            "inputs": {
              "host": {
                "connection": {
                  "name": "@parameters('$connections')['approvals']['connectionId']"
                }
              },
              "method": "post",
              "path": "/approvals",
              "body": {
                "title": "Aprovação de Solicitação",
                "details": "Valor: @{body('parse_email_content')?['amount']}"
              }
            }
          }
        }
      }
    }
  }
}

// Configuração de workflow para onboarding
public class OnboardingWorkflow
{
    public async Task<string> CriarWorkflowOnboardingAsync()
    {
        var workflowDefinition = new
        {
            triggers = new
            {
                novo_funcionario = new
                {
                    type = "manual",
                    inputs = new
                    {
                        schema = new
                        {
                            type = "object",
                            properties = new
                            {
                                nome = new { type = "string" },
                                email = new { type = "string" },
                                departamento = new { type = "string" },
                                cargo = new { type = "string" }
                            }
                        }
                    }
                }
            },
            actions = new
            {
                criar_conta_ad = new
                {
                    type = "Http",
                    inputs = new
                    {
                        method = "POST",
                        uri = "https://graph.microsoft.com/v1.0/users",
                        headers = new { Authorization = "Bearer @{parameters('ad_token')}" },
                        body = new
                        {
                            displayName = "@triggerBody()['nome']",
                            userPrincipalName = "@triggerBody()['email']",
                            department = "@triggerBody()['departamento']"
                        }
                    }
                },
                enviar_email_boas_vindas = new
                {
                    type = "ApiConnection",
                    inputs = new
                    {
                        host = new { connection = new { name = "@parameters('$connections')['outlook']['connectionId']" } },
                        method = "post",
                        path = "/v2/Mail",
                        body = new
                        {
                            To = "@triggerBody()['email']",
                            Subject = "Bem-vindo à empresa!",
                            Body = "Olá @{triggerBody()['nome']}, seja bem-vindo ao time!"
                        }
                    }
                },
                criar_tarefa_ti = new
                {
                    type = "ApiConnection",
                    inputs = new
                    {
                        host = new { connection = new { name = "@parameters('$connections')['planner']['connectionId']" } },
                        method = "post",
                        path = "/v1.0/planner/tasks",
                        body = new
                        {
                            title = "Configurar equipamento para @{triggerBody()['nome']}",
                            assignments = new { it_team = new { } }
                        }
                    }
                }
            }
        };
        
        return JsonSerializer.Serialize(workflowDefinition);
    }
}

public class IntegracaoFinanceira
{
    public async Task ConfigurarWorkflowFinanceiroAsync()
    {
        var workflowDefinition = new
        {
            triggers = new
            {
                nova_fatura = new
                {
                    type = "When_a_file_is_created",
                    inputs = new
                    {
                        host = new { connection = new { name = "@parameters('$connections')['sharepointonline']['connectionId']" } },
                        method = "get",
                        path = "/datasets/@{encodeURIComponent('https://empresa.sharepoint.com/sites/financeiro')}/triggers/onnewfile"
                    }
                }
            },
            actions = new
            {
                analisar_fatura = new
                {
                    type = "ApiConnection",
                    inputs = new
                    {
                        host = new { connection = new { name = "@parameters('$connections')['formrecognizer']['connectionId']" } },
                        method = "post",
                        path = "/v2.1/prebuilt/invoice/analyze",
                        body = "@triggerBody()"
                    }
                },
                validar_dados = new
                {
                    type = "If",
                    expression = new
                    {
                        and = new[]
                        {
                            new { greater = new[] { "@body('analisar_fatura')['analyzeResult']['documentResults'][0]['fields']['InvoiceTotal']['confidence']", 0.8 } },
                            new { not = new { equals = new[] { "@body('analisar_fatura')['analyzeResult']['documentResults'][0]['fields']['VendorName']['text']", null } } }
                        }
                    },
                    actions = new
                    {
                        criar_entrada_erp = new
                        {
                            type = "Http",
                            inputs = new
                            {
                                method = "POST",
                                uri = "https://api.erp-empresa.com/v1/invoices",
                                headers = new { Authorization = "Bearer @{parameters('erp_token')}" },
                                body = new
                                {
                                    vendor = "@body('analisar_fatura')['analyzeResult']['documentResults'][0]['fields']['VendorName']['text']",
                                    total = "@body('analisar_fatura')['analyzeResult']['documentResults'][0]['fields']['InvoiceTotal']['value']",
                                    date = "@body('analisar_fatura')['analyzeResult']['documentResults'][0]['fields']['InvoiceDate']['value']"
                                }
                            }
                        }
                    },
                    @else = new
                    {
                        actions = new
                        {
                            enviar_para_revisao = new
                            {
                                type = "ApiConnection",
                                inputs = new
                                {
                                    host = new { connection = new { name = "@parameters('$connections')['teams']['connectionId']" } },
                                    method = "post",
                                    path = "/v1.0/teams/@{parameters('finance_team_id')}/channels/@{parameters('finance_channel_id')}/messages",
                                    body = new
                                    {
                                        body = new
                                        {
                                            content = "⚠️ Fatura requer revisão manual - baixa confiança na análise"
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        };
        
        await SalvarWorkflowAsync(workflowDefinition);
    }
}

public class ServiceBusManager
{
    private readonly ServiceBusClient _client;
    private readonly ServiceBusSender _sender;
    private readonly ServiceBusReceiver _receiver;
    
    public ServiceBusManager(string connectionString, string queueName)
    {
        _client = new ServiceBusClient(connectionString);
        _sender = _client.CreateSender(queueName);
        _receiver = _client.CreateReceiver(queueName);
    }
    
    // Enviar mensagem
    public async Task EnviarMensagemAsync<T>(T objeto, Dictionary<string, object> propriedades = null)
    {
        var json = JsonSerializer.Serialize(objeto);
        var message = new ServiceBusMessage(json)
        {
            ContentType = "application/json",
            Subject = typeof(T).Name,
            MessageId = Guid.NewGuid().ToString(),
            TimeToLive = TimeSpan.FromHours(24)
        };
        
        // Adicionar propriedades customizadas
        if (propriedades != null)
        {
            foreach (var prop in propriedades)
            {
                message.ApplicationProperties[prop.Key] = prop.Value;
            }
        }
        
        await _sender.SendMessageAsync(message);
    }
    
    // Processar mensagens
    public async Task ProcessarMensagensAsync<T>(Func<T, ServiceBusReceivedMessage, Task> processador)
    {
        while (true)
        {
            var messages = await _receiver.ReceiveMessagesAsync(maxMessages: 10, maxWaitTime: TimeSpan.FromSeconds(30));
            
            if (!messages.Any())
                continue;
                
            var tasks = messages.Select(async message =>
            {
                try
                {
                    var obj = JsonSerializer.Deserialize<T>(message.Body.ToString());
                    await processador(obj, message);
                    
                    // Confirmar processamento
                    await _receiver.CompleteMessageAsync(message);
                }
                catch (Exception ex)
                {
                    // Log do erro
                    Console.WriteLine($"Erro processando mensagem: {ex.Message}");
                    
                    // Verificar tentativas
                    var deliveryCount = message.DeliveryCount;
                    if (deliveryCount >= 3)
                    {
                        // Enviar para Dead Letter Queue
                        await _receiver.DeadLetterMessageAsync(message, "MaxDeliveryCountExceeded");
                    }
                    else
                    {
                        // Abandonar para nova tentativa
                        await _receiver.AbandonMessageAsync(message);
                    }
                }
            });
            
            await Task.WhenAll(tasks);
        }
    }
}

public class SistemaPedidos
{
    private readonly ServiceBusManager _serviceBus;
    
    // Publicar evento de novo pedido
    public async Task ProcessarNovoPedidoAsync(Pedido pedido)
    {
        var evento = new EventoPedidoCriado
        {
            PedidoId = pedido.Id,
            ClienteId = pedido.ClienteId,
            Valor = pedido.ValorTotal,
            Timestamp = DateTime.UtcNow
        };
        
        var propriedades = new Dictionary<string, object>
        {
            ["TipoPedido"] = pedido.Tipo,
            ["Prioridade"] = pedido.Prioridade,
            ["Regiao"] = pedido.Regiao
        };
        
        await _serviceBus.EnviarMensagemAsync(evento, propriedades);
    }
    
    // Processar eventos
    public async Task IniciarProcessamentoEventosAsync()
    {
        await _serviceBus.ProcessarMensagensAsync<EventoPedidoCriado>(async (evento, message) =>
        {
            // Verificar estoque
            var estoqueDisponivel = await VerificarEstoqueAsync(evento.PedidoId);
            
            if (estoqueDisponivel)
            {
                await ProcessarPagamentoAsync(evento.PedidoId);
                await IniciarSeparacaoAsync(evento.PedidoId);
                await EnviarNotificacaoClienteAsync(evento.ClienteId, "Pedido confirmado");
            }
            else
            {
                await EnviarEventoEstoqueInsuficienteAsync(evento);
            }
        });
    }
}

<policies>
    <inbound>
        <!-- Validação de JWT Token -->
        <validate-jwt header-name="Authorization" failed-validation-httpcode="401">
            <openid-config url="https://login.microsoftonline.com/{tenant-id}/v2.0/.well-known/openid_configuration" />
            <required-claims>
                <claim name="scope" match="any">
                    <value>api.read</value>
                    <value>api.write</value>
                </claim>
            </required-claims>
        </validate-jwt>
        
        <!-- Rate Limiting -->
        <rate-limit calls="100" renewal-period="60" remaining-calls-header-name="Remaining-Calls" />
        
        <!-- Transformação de Request -->
        <set-header name="X-Forwarded-For" exists-action="skip">
            <value>@(context.Request.IpAddress)</value>
        </set-header>
        
        <!-- Cache de Response -->
        <cache-lookup vary-by-developer="false" vary-by-developer-groups="false">
            <vary-by-header>Accept</vary-by-header>
            <vary-by-query-parameter>version</vary-by-query-parameter>
        </cache-lookup>
    </inbound>
    
    <backend>
        <!-- Load Balancing -->
        <load-balancer>
            <backend-pool>
                <backend url="https://api1.empresa.com" />
                <backend url="https://api2.empresa.com" />
                <backend url="https://api3.empresa.com" />
            </backend-pool>
        </load-balancer>
    </backend>
    
    <outbound>
        <!-- Transformação de Response -->
        <set-header name="X-API-Version" exists-action="override">
            <value>v2.0</value>
        </set-header>
        
        <!-- Remover headers sensíveis -->
        <set-header name="Server" exists-action="delete" />
        <set-header name="X-Powered-By" exists-action="delete" />
        
        <!-- Cache Store -->
        <cache-store duration="300" />
    </outbound>
    
    <on-error>
        <!-- Log de erros -->
        <log-to-event-hub logger-id="error-logger">
            @{
                return new JObject(
                    new JProperty("timestamp", DateTime.UtcNow),
                    new JProperty("error", context.LastError.Message),
                    new JProperty("requestId", context.RequestId),
                    new JProperty("userId", context.User?.Id),
                    new JProperty("apiId", context.Api.Id)
                ).ToString();
            }
        </log-to-event-hub>
        
        <!-- Response de erro padronizado -->
        <return-response>
            <set-status code="500" reason="Internal Server Error" />
            <set-header name="Content-Type" exists-action="override">
                <value>application/json</value>
            </set-header>
            <set-body>
                @{
                    return new JObject(
                        new JProperty("error", "Erro interno do servidor"),
                        new JProperty("requestId", context.RequestId),
                        new JProperty("timestamp", DateTime.UtcNow)
                    ).ToString();
                }
            </set-body>
        </return-response>
    </on-error>
</policies>

public class APIManagementService
{
    private readonly ApiManagementClient _client;
    
    public async Task ConfigurarGatewayMicroservicosAsync()
    {
        // Configurar API para serviço de usuários
        await CriarAPIAsync(new APIConfiguration
        {
            Name = "usuarios-api",
            DisplayName = "API de Usuários",
            Path = "/usuarios",
            ServiceUrl = "https://usuarios-service.empresa.com",
            Protocols = new[] { "https" },
            Policies = new APIPolicy
            {
                Authentication = AuthenticationType.JWT,
                RateLimit = new RateLimit { Calls = 1000, Period = 3600 },
                Caching = new CachePolicy { Duration = 300 }
            }
        });
        
        // Configurar API para serviço de pedidos
        await CriarAPIAsync(new APIConfiguration
        {
            Name = "pedidos-api",
            DisplayName = "API de Pedidos",
            Path = "/pedidos",
            ServiceUrl = "https://pedidos-service.empresa.com",
            Protocols = new[] { "https" },
            Policies = new APIPolicy
            {
                Authentication = AuthenticationType.JWT,
                RateLimit = new RateLimit { Calls = 500, Period = 3600 },
                Transformation = new TransformationPolicy
                {
                    RequestHeaders = new Dictionary<string, string>
                    {
                        ["X-Service-Version"] = "v2.0"
                    }
                }
            }
        });
    }
    
    public async Task ConfigurarMonitoramentoAsync()
    {
        // Configurar Application Insights
        await _client.DiagnosticSettings.CreateOrUpdateAsync(
            resourceGroupName: "rg-apis",
            serviceName: "api-management-service",
            diagnosticId: "api-diagnostics",
            parameters: new DiagnosticContract
            {
                LoggerId = "/subscriptions/{sub-id}/resourceGroups/rg-apis/providers/Microsoft.Insights/components/app-insights",
                AlwaysLog = AlwaysLog.AllErrors,
                Sampling = new SamplingSettings
                {
                    SamplingType = SamplingType.Fixed,
                    Percentage = 100
                }
            }
        );
    }
}

public class EventGridService
{
    private readonly EventGridPublisherClient _publisherClient;
    private readonly ILogger<EventGridService> _logger;
    
    public EventGridService(string topicEndpoint, string accessKey, ILogger<EventGridService> logger)
    {
        _publisherClient = new EventGridPublisherClient(
            new Uri(topicEndpoint),
            new AzureKeyCredential(accessKey)
        );
        _logger = logger;
    }
    
    public async Task PublicarEventoAsync<T>(string eventType, T data, string subject = null)
    {
        var eventGridEvent = new EventGridEvent(
            subject: subject ?? typeof(T).Name,
            eventType: eventType,
            dataVersion: "1.0",
            data: BinaryData.FromObjectAsJson(data)
        )
        {
            Id = Guid.NewGuid().ToString(),
            EventTime = DateTimeOffset.UtcNow
        };
        
        try
        {
            await _publisherClient.SendEventAsync(eventGridEvent);
            _logger.LogInformation("Evento publicado: {EventType}", eventType);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Erro ao publicar evento: {EventType}", eventType);
            throw;
        }
    }
    
    public async Task PublicarEventosLoteAsync<T>(IEnumerable<(string eventType, T data, string subject)> eventos)
    {
        var eventGridEvents = eventos.Select(e => new EventGridEvent(
            subject: e.subject ?? typeof(T).Name,
            eventType: e.eventType,
            dataVersion: "1.0",
            data: BinaryData.FromObjectAsJson(e.data)
        )
        {
            Id = Guid.NewGuid().ToString(),
            EventTime = DateTimeOffset.UtcNow
        }).ToList();
        
        try
        {
            await _publisherClient.SendEventsAsync(eventGridEvents);
            _logger.LogInformation("Lote de {Count} eventos publicado", eventGridEvents.Count);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Erro ao publicar lote de eventos");
            throw;
        }
    }
}

public class EcommerceEventSystem
{
    private readonly EventGridService _eventGrid;
    
    // Eventos do sistema
    public async Task ProcessarCompraAsync(Pedido pedido)
    {
        // 1. Evento de pedido criado
        await _eventGrid.PublicarEventoAsync(
            "ecommerce.pedido.criado",
            new PedidoCriadoEvent
            {
                PedidoId = pedido.Id,
                ClienteId = pedido.ClienteId,
                Valor = pedido.ValorTotal,
                Items = pedido.Items.Select(i => new ItemEvent
                {
                    ProdutoId = i.ProdutoId,
                    Quantidade = i.Quantidade,
                    Preco = i.Preco
                }).ToList()
            },
            $"pedidos/{pedido.Id}"
        );
        
        // 2. Evento de estoque reduzido
        foreach (var item in pedido.Items)
        {
            await _eventGrid.PublicarEventoAsync(
                "estoque.produto.reduzido",
                new EstoqueReduzidoEvent
                {
                    ProdutoId = item.ProdutoId,
                    QuantidadeReduzida = item.Quantidade,
                    EstoqueAtual = await ObterEstoqueAtualAsync(item.ProdutoId)
                },
                $"produtos/{item.ProdutoId}"
            );
        }
    }
    
    // Handler para eventos
    [FunctionName("ProcessarEventoPedido")]
    public async Task ProcessarEventoPedidoAsync(
        [EventGridTrigger] EventGridEvent eventGridEvent,
        ILogger log)
    {
        log.LogInformation($"Processando evento: {eventGridEvent.EventType}");
        
        switch (eventGridEvent.EventType)
        {
            case "ecommerce.pedido.criado":
                var pedidoEvent = eventGridEvent.Data.ToObjectFromJson<PedidoCriadoEvent>();
                await ProcessarNovoPedidoAsync(pedidoEvent);
                break;
                
            case "estoque.produto.reduzido":
                var estoqueEvent = eventGridEvent.Data.ToObjectFromJson<EstoqueReduzidoEvent>();
                await VerificarEstoqueBaixoAsync(estoqueEvent);
                break;
                
            case "pagamento.processado":
                var pagamentoEvent = eventGridEvent.Data.ToObjectFromJson<PagamentoProcessadoEvent>();
                await ConfirmarPedidoAsync(pagamentoEvent);
                break;
        }
    }
    
    private async Task ProcessarNovoPedidoAsync(PedidoCriadoEvent evento)
    {
        // Validar estoque
        foreach (var item in evento.Items)
        {
            var estoque = await _estoqueService.VerificarEstoqueAsync(item.ProdutoId);
            if (estoque < item.Quantidade)
            {
                await _eventGrid.PublicarEventoAsync(
                    "ecommerce.pedido.estoque_insuficiente",
                    new EstoqueInsuficienteEvent
                    {
                        PedidoId = evento.PedidoId,
                        ProdutoId = item.ProdutoId,
                        QuantidadeSolicitada = item.Quantidade,
                        EstoqueDisponivel = estoque
                    }
                );
                return;
            }
        }
        
        // Processar pagamento
        await _pagamentoService.ProcessarPagamentoAsync(evento.PedidoId);
    }
}

public class ProcessamentoImagens
{
    private readonly ComputerVisionClient _visionClient;
    private readonly BlobServiceClient _blobClient;
    
    [FunctionName("ProcessarImagemUpload")]
    public async Task ProcessarImagemUploadAsync(
        [BlobTrigger("imagens-upload/{name}", Connection = "StorageConnection")] Stream imageStream,
        string name,
        [Blob("imagens-processadas/{name}", FileAccess.Write, Connection = "StorageConnection")] Stream outputStream,
        ILogger log)
    {
        log.LogInformation($"Processando imagem: {name}");
        
        try
        {
            // 1. Analisar imagem com Computer Vision
            var analise = await _visionClient.AnalyzeImageInStreamAsync(
                imageStream,
                new List<VisualFeatureTypes> 
                { 
                    VisualFeatureTypes.Objects,
                    VisualFeatureTypes.Tags,
                    VisualFeatureTypes.Description
                }
            );
            
            // 2. Redimensionar imagem
            imageStream.Position = 0;
            using var image = Image.Load(imageStream);
            image.Mutate(x => x.Resize(800, 600));
            
            // 3. Adicionar watermark
            var watermark = await CriarWatermarkAsync(analise.Description.Captions.FirstOrDefault()?.Text);
            image.Mutate(x => x.DrawImage(watermark, new Point(10, 10), 0.7f));
            
            // 4. Salvar imagem processada
            await image.SaveAsync(outputStream, new JpegEncoder { Quality = 85 });
            
            // 5. Salvar metadados
            await SalvarMetadados(name, analise);
            
            log.LogInformation($"Imagem processada com sucesso: {name}");
        }
        catch (Exception ex)
        {
            log.LogError(ex, $"Erro ao processar imagem: {name}");
            throw;
        }
    }
    
    [FunctionName("GerarRelatorioImagens")]
    public async Task<IActionResult> GerarRelatorioImagensAsync(
        [HttpTrigger(AuthorizationLevel.Function, "get", Route = "relatorio/imagens")] HttpRequest req,
        ILogger log)
    {
        var dataInicio = DateTime.Parse(req.Query["dataInicio"]);
        var dataFim = DateTime.Parse(req.Query["dataFim"]);
        
        var metadados = await ObterMetadadosAsync(dataInicio, dataFim);
        
        var relatorio = new
        {
            Periodo = new { Inicio = dataInicio, Fim = dataFim },
            TotalImagens = metadados.Count,
            TagsMaisComuns = metadados
                .SelectMany(m => m.Tags)
                .GroupBy(t => t.Name)
                .OrderByDescending(g => g.Count())
                .Take(10)
                .Select(g => new { Tag = g.Key, Quantidade = g.Count() }),
            ObjetosMaisDetectados = metadados
                .SelectMany(m => m.Objects)
                .GroupBy(o => o.ObjectProperty)
                .OrderByDescending(g => g.Count())
                .Take(10)
                .Select(g => new { Objeto = g.Key, Quantidade = g.Count() })
        };
        
        return new OkObjectResult(relatorio);
    }
}

public class EventSourcingArchitecture
{
    private readonly EventGridService _eventGrid;
    private readonly CosmosClient _cosmosClient;
    
    // Event Store
    public async Task SalvarEventoAsync<T>(string aggregateId, string eventType, T eventData, int expectedVersion)
    {
        var evento = new EventRecord
        {
            Id = Guid.NewGuid().ToString(),
            AggregateId = aggregateId,
            EventType = eventType,
            EventData = JsonSerializer.Serialize(eventData),
            Version = expectedVersion + 1,
            Timestamp = DateTime.UtcNow
        };
        
        // Salvar no Event Store (Cosmos DB)
        var container = _cosmosClient.GetContainer("EventStore", "Events");
        await container.CreateItemAsync(evento, new PartitionKey(aggregateId));
        
        // Publicar evento para processamento
        await _eventGrid.PublicarEventoAsync(eventType, eventData, aggregateId);
    }
    
    // Reconstruir estado do agregado
    public async Task<T> ReconstruirAgregadoAsync<T>(string aggregateId) where T : class, new()
    {
        var container = _cosmosClient.GetContainer("EventStore", "Events");
        
        var query = container.GetItemQueryIterator<EventRecord>(
            $"SELECT * FROM c WHERE c.aggregateId = '{aggregateId}' ORDER BY c.version"
        );
        
        var eventos = new List<EventRecord>();
        while (query.HasMoreResults)
        {
            var response = await query.ReadNextAsync();
            eventos.AddRange(response);
        }
        
        var agregado = new T();
        foreach (var evento in eventos)
        {
            AplicarEvento(agregado, evento);
        }
        
        return agregado;
    }
    
    // Projeção de Read Model
    [FunctionName("AtualizarProjecao")]
    public async Task AtualizarProjecaoAsync(
        [EventGridTrigger] EventGridEvent eventGridEvent,
        ILogger log)
    {
        var container = _cosmosClient.GetContainer("ReadModels", "Projections");
        
        switch (eventGridEvent.EventType)
        {
            case "pedido.criado":
                var pedidoEvent = eventGridEvent.Data.ToObjectFromJson<PedidoCriadoEvent>();
                await AtualizarProjecaoPedidoAsync(container, pedidoEvent);
                break;
                
            case "pagamento.processado":
                var pagamentoEvent = eventGridEvent.Data.ToObjectFromJson<PagamentoProcessadoEvent>();
                await AtualizarProjecaoPagamentoAsync(container, pagamentoEvent);
                break;
        }
    }
}

public class CQRSArchitecture
{
    // Command Side
    public class PedidoCommandHandler
    {
        private readonly ServiceBusManager _commandBus;
        private readonly EventSourcingArchitecture _eventStore;
        
        public async Task<CommandResult> HandleAsync(CriarPedidoCommand command)
        {
            try
            {
                // Validar comando
                var validationResult = await ValidarComandoAsync(command);
                if (!validationResult.IsValid)
                {
                    return CommandResult.Failure(validationResult.Errors);
                }
                
                // Carregar agregado ou criar novo
                var pedido = await CarregarOuCriarPedidoAsync(command.PedidoId);
                
                // Executar lógica de negócio
                var eventos = pedido.CriarPedido(command);
                
                // Salvar eventos
                foreach (var evento in eventos)
                {
                    await _eventStore.SalvarEventoAsync(
                        command.PedidoId,
                        evento.GetType().Name,
                        evento,
                        pedido.Version
                    );
                }
                
                return CommandResult.Success();
            }
            catch (Exception ex)
            {
                return CommandResult.Failure(ex.Message);
            }
        }
    }
    
    // Query Side
    public class PedidoQueryHandler
    {
        private readonly CosmosClient _readModelStore;
        
        public async Task<PedidoReadModel> GetPedidoAsync(string pedidoId)
        {
            var container = _readModelStore.GetContainer("ReadModels", "Pedidos");
            
            try
            {
                var response = await container.ReadItemAsync<PedidoReadModel>(pedidoId, new PartitionKey(pedidoId));
                return response.Resource;
            }
            catch (CosmosException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
            {
                return null;
            }
        }
        
        public async Task<IEnumerable<PedidoReadModel>> GetPedidosClienteAsync(string clienteId, int page = 1, int pageSize = 20)
        {
            var container = _readModelStore.GetContainer("ReadModels", "Pedidos");
            
            var query = container.GetItemQueryIterator<PedidoReadModel>(
                $"SELECT * FROM c WHERE c.clienteId = '{clienteId}' ORDER BY c.dataCriacao DESC OFFSET {(page - 1) * pageSize} LIMIT {pageSize}"
            );
            
            var resultados = new List<PedidoReadModel>();
            while (query.HasMoreResults)
            {
                var response = await query.ReadNextAsync();
                resultados.AddRange(response);
            }
            
            return resultados;
        }
    }
}

public class MonitoramentoIntegracoes
{
    private readonly IMetricsLogger _metricsLogger;
    private readonly ApplicationInsightsClient _appInsights;
    
    public async Task<DashboardMetrics> ObterMetricasGeraisAsync(DateTime inicio, DateTime fim)
    {
        var tasks = new[]
        {
            ObterMetricasLogicAppsAsync(inicio, fim),
            ObterMetricasServiceBusAsync(inicio, fim),
            ObterMetricasAPIManagementAsync(inicio, fim),
            ObterMetricasEventGridAsync(inicio, fim),
            ObterMetricasFunctionsAsync(inicio, fim)
        };
        
        var resultados = await Task.WhenAll(tasks);
        
        return new DashboardMetrics
        {
            LogicApps = resultados[0],
            ServiceBus = resultados[1],
            APIManagement = resultados[2],
            EventGrid = resultados[3],
            Functions = resultados[4],
            SaudeGeral = CalcularSaudeGeral(resultados),
            AlertasAtivos = await ObterAlertasAtivosAsync()
        };
    }
    
    public async Task ConfigurarAlertas()
    {
        // Alertas para Logic Apps
        await CriarAlertaAsync(new AlertConfig
        {
            Nome = "LogicApp-FailureRate",
            Descricao = "Taxa de falha em Logic Apps acima de 5%",
            MetricaAlvo = "microsoft.logic/workflows",
            Condicao = new AlertCondition
            {
                Operador = "GreaterThan",
                Threshold = 0.05,
                TimeWindow = TimeSpan.FromMinutes(5)
            },
            Acoes = new[]
            {
                new AlertAction { Tipo = "Email", Destinatario = "ops@empresa.com" },
                new AlertAction { Tipo = "Teams", Canal = "alerts-channel" },
                new AlertAction { Tipo = "PagerDuty", ServiceKey = "logic-apps-service" }
            }
        });
        
        // Alertas para Service Bus
        await CriarAlertaAsync(new AlertConfig
        {
            Nome = "ServiceBus-QueueLength",
            Descricao = "Tamanho da fila Service Bus acima de 1000",
            MetricaAlvo = "microsoft.servicebus/namespaces",
            Condicao = new AlertCondition
            {
                Operador = "GreaterThan",
                Threshold = 1000,
                TimeWindow = TimeSpan.FromMinutes(10)
            }
        });
        
        // Alertas para API Management
        await CriarAlertaAsync(new AlertConfig
        {
            Nome = "APIM-ResponseTime",
            Descricao = "Tempo de resposta API Management acima de 5 segundos",
            MetricaAlvo = "microsoft.apimanagement/service",
            Condicao = new AlertCondition
            {
                Operador = "GreaterThan",
                Threshold = 5000,
                TimeWindow = TimeSpan.FromMinutes(5)
            }
        });
    }
}

public class DistributedTracing
{
    private static readonly ActivitySource ActivitySource = new("Azure.Integration.Services");
    
    public async Task<T> ExecutarComTracingAsync<T>(
        string operationName,
        Func<Activity, Task<T>> operation,
        Dictionary<string, object> tags = null)
    {
        using var activity = ActivitySource.StartActivity(operationName);
        
        // Adicionar tags padrão
        activity?.SetTag("service.name", "integration-platform");
        activity?.SetTag("service.version", "1.0");
        
        // Adicionar tags customizadas
        if (tags != null)
        {
            foreach (var tag in tags)
            {
                activity?.SetTag(tag.Key, tag.Value);
            }
        }
        
        try
        {
            var result = await operation(activity);
            activity?.SetStatus(ActivityStatusCode.Ok);
            return result;
        }
        catch (Exception ex)
        {
            activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
            activity?.SetTag("error.message", ex.Message);
            activity?.SetTag("error.type", ex.GetType().Name);
            throw;
        }
    }
    
    // Exemplo de uso em Logic App
    public async Task ExecutarWorkflowComTracingAsync(string workflowName, object input)
    {
        await ExecutarComTracingAsync(
            $"logic-app.{workflowName}.execute",
            async (activity) =>
            {
                activity?.SetTag("workflow.name", workflowName);
                activity?.SetTag("workflow.input.size", JsonSerializer.Serialize(input).Length);
                
                // Propagar trace context para chamadas HTTP
                var headers = new Dictionary<string, string>();
                DistributedContextPropagator.Current.Inject(
                    new PropagationContext(activity?.Context ?? default, Baggage.Current),
                    headers,
                    (carrier, key, value) => carrier[key] = value
                );
                
                // Executar workflow
                var result = await _logicAppClient.ExecuteWorkflowAsync(workflowName, input, headers);
                
                activity?.SetTag("workflow.result.status", result.Status);
                activity?.SetTag("workflow.duration.ms", result.Duration.TotalMilliseconds);
                
                return result;
            },
            new Dictionary<string, object>
            {
                ["workflow.type"] = "integration",
                ["input.type"] = input.GetType().Name
            }
        );
    }
}

public class ZeroTrustSecurity
{
    private readonly ITokenValidationService _tokenValidation;
    private readonly IAuditLogger _auditLogger;
    
    public async Task<AuthorizationResult> ValidarAcessoAsync(
        string token,
        string resource,
        string action,
        string userContext)
    {
        // 1. Validar token JWT
        var tokenValidation = await _tokenValidation.ValidateTokenAsync(token);
        if (!tokenValidation.IsValid)
        {
            await _auditLogger.LogUnauthorizedAccessAsync(resource, action, "Invalid token");
            return AuthorizationResult.Deny("Token inválido");
        }
        
        // 2. Verificar permissões RBAC
        var permissions = await GetUserPermissionsAsync(tokenValidation.UserId);
        if (!permissions.CanAccess(resource, action))
        {
            await _auditLogger.LogUnauthorizedAccessAsync(resource, action, $"User {tokenValidation.UserId} lacks permission");
            return AuthorizationResult.Deny("Permissão insuficiente");
        }
        
        // 3. Verificar contexto de acesso
        var riskScore = await CalculateRiskScoreAsync(tokenValidation.UserId, userContext);
        if (riskScore > 0.8)
        {
            await _auditLogger.LogHighRiskAccessAsync(resource, action, tokenValidation.UserId, riskScore);
            return AuthorizationResult.RequireMFA("Acesso de alto risco - MFA necessário");
        }
        
        // 4. Log de acesso autorizado
        await _auditLogger.LogAuthorizedAccessAsync(resource, action, tokenValidation.UserId);
        
        return AuthorizationResult.Allow();
    }
    
    private async Task<double> CalculateRiskScoreAsync(string userId, string context)
    {
        var factors = new[]
        {
            await CheckGeolocationRiskAsync(context),
            await CheckDeviceRiskAsync(context),
            await CheckTimeRiskAsync(context),
            await CheckBehaviorRiskAsync(userId, context)
        };
        
        return factors.Average();
    }
}

public class DataEncryptionService
{
    private readonly KeyVaultClient _keyVault;
    
    public async Task<EncryptedData> EncryptAsync(string data, string keyName)
    {
        // Obter chave do Azure Key Vault
        var key = await _keyVault.GetKeyAsync(keyName);
        
        // Gerar IV aleatório
        var iv = new byte[16];
        using (var rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(iv);
        }
        
        // Criptografar dados
        using var aes = Aes.Create();
        aes.Key = key.Key;
        aes.IV = iv;
        
        using var encryptor = aes.CreateEncryptor();
        using var ms = new MemoryStream();
        using var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write);
        using var writer = new StreamWriter(cs);
        
        await writer.WriteAsync(data);
        await writer.FlushAsync();
        cs.FlushFinalBlock();
        
        return new EncryptedData
        {
            Data = Convert.ToBase64String(ms.ToArray()),
            IV = Convert.ToBase64String(iv),
            KeyName = keyName,
            Algorithm = "AES-256-CBC"
        };
    }
    
    public async Task<string> DecryptAsync(EncryptedData encryptedData)
    {
        // Obter chave do Azure Key Vault
        var key = await _keyVault.GetKeyAsync(encryptedData.KeyName);
        
        // Descriptografar dados
        using var aes = Aes.Create();
        aes.Key = key.Key;
        aes.IV = Convert.FromBase64String(encryptedData.IV);
        
        using var decryptor = aes.CreateDecryptor();
        using var ms = new MemoryStream(Convert.FromBase64String(encryptedData.Data));
        using var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read);
        using var reader = new StreamReader(cs);
        
        return await reader.ReadToEndAsync();
    }
}

public class ROICalculator
{
    public ROIAnalysis CalculateIntegrationROI(IntegrationMetrics metrics)
    {
        // Custos
        var totalCosts = new TotalCosts
        {
            PlatformCosts = CalculatePlatformCosts(metrics),
            DevelopmentCosts = CalculateDevelopmentCosts(metrics),
            MaintenanceCosts = CalculateMaintenanceCosts(metrics),
            TrainingCosts = CalculateTrainingCosts(metrics)
        };
        
        // Benefícios
        var totalBenefits = new TotalBenefits
        {
            OperationalEfficiency = CalculateEfficiencyGains(metrics),
            ErrorReduction = CalculateErrorReductionSavings(metrics),
            TimeToMarket = CalculateTimeToMarketImprovement(metrics),
            ScalabilitySavings = CalculateScalabilitySavings(metrics),
            ComplianceSavings = CalculateComplianceSavings(metrics)
        };
        
        var netBenefit = totalBenefits.Total - totalCosts.Total;
        var roiPercentage = (netBenefit / totalCosts.Total) * 100;
        var paybackPeriod = totalCosts.Total / (totalBenefits.Total / 12); // meses
        
        return new ROIAnalysis
        {
            TotalCosts = totalCosts.Total,
            TotalBenefits = totalBenefits.Total,
            NetBenefit = netBenefit,
            ROIPercentage = roiPercentage,
            PaybackPeriodMonths = paybackPeriod,
            BreakEvenDate = DateTime.Now.AddMonths((int)Math.Ceiling(paybackPeriod)),
            CostBreakdown = totalCosts,
            BenefitBreakdown = totalBenefits
        };
    }
    
    private decimal CalculateEfficiencyGains(IntegrationMetrics metrics)
    {
        // Tempo economizado em processos manuais
        var manualHoursReduced = metrics.ProcessesAutomated * metrics.AverageTimePerProcess;
        var hourlyCost = 50m; // custo médio por hora
        
        return manualHoursReduced * hourlyCost * 12; // anual
    }
    
    private decimal CalculateErrorReductionSavings(IntegrationMetrics metrics)
    {
        // Redução de erros humanos
        var errorReduction = metrics.ErrorRate.Before - metrics.ErrorRate.After;
        var costPerError = 250m; // custo médio para corrigir um erro
        var transactionsPerYear = metrics.MonthlyTransactions * 12;
        
        return errorReduction * costPerError * transactionsPerYear;
    }
}

public class ManufacturingIntegrationCase
{
    // Integração MES -> ERP -> CRM
    public async Task ImplementarIntegracaoManufaturaAsync()
    {
        // 1. Logic App para processar dados de produção
        var workflowProducao = new LogicAppWorkflow
        {
            Name = "MES-to-ERP-Integration",
            Trigger = new ServiceBusTrigger("mes-production-queue"),
            Actions = new[]
            {
                new ParseJSONAction("production-data"),
                new ConditionAction("quality-check", 
                    condition: "@greater(body('production-data')['quality_score'], 0.95)",
                    ifTrue: new[]
                    {
                        new HTTPAction("update-erp", "https://erp.empresa.com/api/production"),
                        new EventGridAction("production.quality.approved")
                    },
                    ifFalse: new[]
                    {
                        new EventGridAction("production.quality.rejected"),
                        new TeamsAction("alert-quality-team")
                    }
                )
            }
        };
        
        // 2. API Management para expor dados de produção
        await ConfigurarAPIProducaoAsync();
        
        // 3. Event Grid para notificações em tempo real
        await ConfigurarEventosProducaoAsync();
    }
    
    // Resultados obtidos:
    // - 70% redução no tempo de processamento de dados
    // - 95% redução de erros manuais
    // - ROI de 340% em 18 meses
    // - Visibilidade em tempo real da produção
}

public class FinancialServicesIntegration
{
    // Integração Core Banking -> Analytics -> Regulatório
    public async Task ImplementarComplianceAutomationAsync()
    {
        // 1. Functions para processamento de transações
        var functionProcessamento = new AzureFunction
        {
            Trigger = new CosmosDBTrigger("transactions"),
            Actions = new[]
            {
                "AnalyzeFraudRisk",
                "CheckComplianceRules",
                "UpdateRiskProfile",
                "GenerateAlerts"
            }
        };
        
        // 2. Logic Apps para relatórios regulatórios
        var workflowRelatorios = new LogicAppWorkflow
        {
            Trigger = new TimerTrigger("0 0 9 * * MON"), // Segunda-feira 9h
            Actions = new[]
            {
                new SQLAction("extract-weekly-data"),
                new ExcelAction("generate-report"),
                new EmailAction("send-to-regulator"),
                new SharePointAction("archive-report")
            }
        };
        
        // Resultados:
        // - 90% redução no tempo de geração de relatórios
        // - 100% automação de compliance checks
        // - ROI de 450% em 12 meses
    }
}