Executando um pipeline

Até agora, o pipeline foi apenas um esquema puro. A materialização é o processo que transforma esse esquema em atores em execução que realmente movimentam os dados.

Nada acontece até que você execute explicitamente o grafo, e é isso que torna o Akka Streams componível e reutilizável.

A materialização requer um ActorSystem, que fornece as threads e o despachante que dão suporte aos estágios do fluxo. No Akka moderno, o sistema também atua como o materializador implícito.

Normalmente, um ActorSystem atende a toda uma aplicação e a muitos fluxos simultâneos.

A maneira mais direta de executar uma Source é runWith, que conecta um Sink e o materializa em uma única etapa, retornando o valor materializado desse Sink.

Aqui, o resultado é um Future[Int] que é concluído com a soma quando o fluxo termina.

Se você já tiver criado um RunnableGraph fechado com to ou toMat, chame run() para materializá-lo. O valor retornado é qualquer valor materializado que o grafo tenha mantido.

Isso separa claramente a construção do pipeline da execução.

As Sources oferecem atalhos: runForeach, runFold e runReduce conectam cada um o Sink correspondente e executam imediatamente.

Eles são concisos para operações terminais comuns em uma Source.

Os Sinks terminais retornam um Future que é concluído quando o fluxo termina ou falha. Registre retornos de chamada com onComplete para reagir ao sucesso ou ao erro.

Use o despachante do ActorSystem como o ExecutionContext implícito para esses retornos de chamada.

Um pipeline de dados típico lê de uma Source, transforma os dados com Flows, realiza E/S assíncrona com mapAsync, agrupa com grouped e grava em um Sink.

Cada estágio é pequeno, e todo o conjunto é materializado com um único run.

Para obter resiliência, envolva uma Source ou um Flow com RestartSource.withBackoff, para que falhas temporárias (como uma conexão interrompida) acionem uma reinicialização automática com espera exponencial.

Isso mantém pipelines de ingestão de longa duração ativos sem supervisão manual.

Um KillSwitch permite que um código externo pare um fluxo em execução de forma limpa. Insira KillSwitches.single por meio de viaMat e mantenha seu valor materializado para chamar shutdown() mais tarde.

Isso é essencial para fluxos de longa duração que precisam parar quando a aplicação for encerrada.

Quando a aplicação for encerrada, termine o ActorSystem para liberar suas threads. Encadeie a chamada de encerramento após o Future de conclusão do fluxo, para que o desligamento ocorra de forma ordenada.

Deixar um ActorSystem aberto mantém a JVM ativa e conserva os recursos ocupados.

Materializar o mesmo esquema várias vezes cria fluxos independentes em execução que compartilham os recursos do ActorSystem. O próprio esquema permanece imutável e sem efeitos colaterais.

Isso permite definir um pipeline uma vez e executá-lo sob demanda para cada novo trabalho recebido.

Considere o que é necessário para que um fluxo realmente processe elementos.

Executar um pipeline significa materializar um esquema com um ActorSystem por meio de run, runWith ou operadores de conveniência, cada um retornando um resultado Future.

Você conheceu pipelines realistas com vários estágios, reinicializações automáticas com espera progressiva, encerramento controlado por meio de KillSwitch, liberação de recursos com system.terminate() e reutilização segura de um esquema imutável em execuções independentes.