Olá esse é o integration developer bootcamp estamos na etapa de arquitetura e padrões de projeto 1 hoje falaremos sobre escalonamento e paralelismo na plataforma Começando por escalonamento vertical nós podemos aumentar poder de processamento dos nossos pipelines por meio da escala vertical Então temos diversos tipos de pipelines na plataforma que são small médium e large e eles aumentam a quantidade de Ram e a quantidade de ou que cada pipeline é capaz de consumir essa parte que está escrito consumidores nos diz sobre a quantidade de execuções simultâneas que o pipeline consegue fazer então pipeline em versão small
ele consegue executar até 10 vezes ao mesmo tempo utilizando essa quantidade de CPU e essa quantidade de Ram então esses valores são distribuídos entre todas as execuções simultâneas caso eu queira utilizar todo esse Potencial em uma única execução eu diminuo a quantidade de consumidores para um por exemplo e essa única execução vai consumir todos esses valores de CPU e de memória RAM os outros meios de utilizar como médium e large eles duplicam e duplicam novamente a tanto a quantidade de consumidores quanto a quantidade de CPU e memória RAM então caso eu precise de um pipeline
que tenha que aguentar um payload mais maior com mais memória RAM um processamento mais elevado eu preciso de aumentar verticalmente meu pipeline e eu resolvo esse problema um exemplo de um small versus um l é que um pipeline exatamente idêntico publicado em small e publicado em large com a mesma quantidade de consumidores pros dois eu tenho por exemplo que o small ocupou mais do que 50 e atingiu perto dos 80 e poucos por de memória R enquanto L estava na casa dos 15% e atingiu um limite de 40% de memória RAM Isso é uma tração
que dois pipelines diferentes mas que possuem os mesmos componentes possuem um consumo de memória diferente justamente por est em small ou ST large essas informações foram retiradas da aba de monitoramento da plataforma agora falando de escala horizontal temos o seguinte vamos supor que tem que cada container desse seja um pipeline small com 10 execuções simultâneas caso eu precise aqui de mais execuções simultâneas e não de mais poder computacional eu devo fazer réplicas dos meus pipelines e não aumentar a a escala vertical dele para aumentar a quantidade de consumidores assim aumentando a quantidade de réplicas temos
diversos pipeline small em que cada um consegue executar até 10 execuções simultâneas então supondo que eu precisava de 100 execuções ao mesmo tempo e não apenas 10 Eu precisaria contratar 10 pipelines 10 réplicas de pipeline small por exemplo e aqui é o seguinte a medida que as mensagens são entregues para esses pipelines para esses containers nós vamos preenchendo a quantidade de execução simultânea e uma vez que foi preenchido a gente passa pro próximo contêiner e assim por diante aqui vamos dar um exemplo de paralelismo aqui temos Um pipeline publicador de eventos então um Trigger de
schedular por exemplo temos uma fonte de dados um componente de looping ou de stram e para cada dado retornado dessa fonte nós vamos publicar um evento depois disso O Event broker vai recuperar esses eventos vai entregar essa mensagem para quem estiver inscrito a esse evento e teremos um pipeline consumidor que fará por exemplo uma transformação e uma requisição web qualquer Então aqui tem o seguinte temos um pipeline que na sua execução ele recupera muitos dados e Public muitos eventos e aqui temos outro pipeline pega cada um desse dado e faz uma transformação e e uma
chamada web para um registro específico aqui nós vamos ter por exemplo 10 execuções desse pipeline ao mesmo tempo mas podemos aumentar essas execuções aumentando a quantidade de réplicas E é isso que a gente vai ver agora temos um exemplo de pipeline que faz consuma uma base de dados e para cada registro ele publica um evento e temos esse pipeline que está ouvindo esse evento e será ativado assim que for publicado esse pipeline de tamanho small com apenas uma réplica Demorou 51 segundos para processar 500 registros o mesmo pipeline com cinco réplicas Demorou 24 segundos para
processar 500 registros então conseguimos um ganho de 100% na velocidade de processamento desse desses dados isso acontece porque aumentar a quantidade de de réplica de um pipeline nos permite maior quantidade de execuções simultâneas então atingimos o pico de 50 execuções simultâneas E aí nós processamos mais rápidos registros por conta disso caso aumentássemos ainda mais de 500 para por exemplo 3.000 registros veríamos isso ainda com mais intensidade visto que nos pipelines com cinco réplicas teremos que 50 execuções simultâneas por mais tempo vamos dar um exemplo vamos processar agora Sete Vezes Mais registros nós Demoramos 115 segundos
para processar 3500 registros nesse caso as 50 execuções simultâneas são utilizadas por mais tempo nós temos o aumento aqui até o preenchimento de todo o contêiner e esse contêiner fica preenchido com esses 50 execuções até ele esvaziar a fila Fazer uma comparação entre os dois casos temos 24 segundos para processar 500 registros com eventos preenchendo o container indo ao pico de 50 e depois caindo e temos o caso de 115 segundos para processar 3500 registros em que enchemos o contêiner e ele possui 50 execuções simultâneas por mais tempo entretanto o que que acontece com as
mensagens que foram publicadas porém não foram processadas ainda por conta do limite de 50 de execuções nesse caso que aumentamos a volumetria O Event broker da plataforma JB que é um rapt MQ vai enfileirar os eventos restantes E à medida que o nosso contêiner for esvaziando por meio das execuções simultâneas essa fila ela vai ser consumida com o tempo nosso contêiner vai pegar esses eventos da que estão em fila e logo após que finalizarmos toda essa fila todas as execuções simultâneas vão cair novamente Então essa foi a apresentação sobre paralelismo e escalonamento e nos vemos
nos próximos vídeos
