<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Juan Caio on Medium]]></title>
        <description><![CDATA[Stories by Juan Caio on Medium]]></description>
        <link>https://medium.com/@juancaio?source=rss-f6b51ceba38c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*RtUoE_qD2VvQG_kHn4iyzA.jpeg</url>
            <title>Stories by Juan Caio on Medium</title>
            <link>https://medium.com/@juancaio?source=rss-f6b51ceba38c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:43:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@juancaio/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Diferenças entre o Scala Spark e o PySpark]]></title>
            <link>https://medium.com/@juancaio/diferen%C3%A7as-entre-o-scala-spark-e-o-pyspark-793e0bc32ca5?source=rss-f6b51ceba38c------2</link>
            <guid isPermaLink="false">https://medium.com/p/793e0bc32ca5</guid>
            <category><![CDATA[scala]]></category>
            <category><![CDATA[spark]]></category>
            <category><![CDATA[pyspark]]></category>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Juan Caio]]></dc:creator>
            <pubDate>Fri, 17 Mar 2023 19:31:46 GMT</pubDate>
            <atom:updated>2023-03-17T19:31:46.830Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/378/1*WINhzRdqi5WieBsRyeP6aQ.png" /></figure><p>O código do Apache Spark pode ser escrito com as APIs Scala, Java, Python ou R. Scala e Python são as APIs mais populares.</p><p>Ambas linguagens são ótimas opções para a maioria dos fluxos de trabalho. O Spark permite que você escreva um código elegante de forma bem simples.</p><p>A escolha da linguagem correta é uma decisão muito importante, depois que você inicia o seu projeto com uma linguagem fica muito difícil vc mudar.</p><p>Fazer a escolha certa é difícil devido a equívocos comuns como “<em>Scala é 10x mais rápido que Python</em>”, que são completamente enganosos ao comparar Scala Spark e PySpark.</p><h3>Principais diferenças:</h3><ul><li>Embora <strong>o Scala</strong> nos permita usar o Spark atualizado sem quebrar nosso código, ele tem <strong>muito menos bibliotecas do que o PySpark</strong>. Como o PySpark é baseado em Python, ele possui todas as bibliotecas para processamento de texto, aprendizado profundo e visualização que o Scala não possui.</li><li><strong>Python</strong> é uma linguagem de interpretação e uma linguagem que está <strong>muito na moda</strong>. Por isso, é um idioma que muitas pessoas conhecem e é fácil de aprender. Como resultado, quando você começa a usar o PySpark, o ambiente é mais familiar porque as chamadas para o Spark são feitas por meio de funções muito semelhantes às do Python. Além da própria legibilidade, a <strong>curva de aprendizado do PySpark é menor</strong>, pois <strong>não possui a complexa sintaxe Scala</strong> necessária para definir os operadores.</li><li>O PySpark costumava ser cheio de bugs e mal suportado, mas isso não é mais verdade. Hoje em dia o python tem seu lugar de destaque dentro do Spark.</li><li>Scala é uma linguagem type-safe em tempo de compilação, por isso oferece certos recursos que não podem ser oferecidos no PySpark, como conjuntos de dados.</li><li>Muitas das vantagens do Scala não importam no ambiente de notebook Databricks. Notebooks não suportam recursos oferecidos por IDEs ou empacotadores de código de nível de produção, portanto, se você for trabalhar estritamente com notebooks, não espere se beneficiar das vantagens do Scala.</li></ul><h3>Conclusão</h3><p>Tanto o Python quanto o Scala são ótimas linguagens para maioria de fluxos de trabalho no Spark.</p><p>O PySpark é mais popular porque Python é a linguagem mais popular no mundo dos dados, além de possuir um ótimo suporte e vem tendo muitas melhorias dentro da comunidade do Spark.</p><p>O Scala é uma linguagem de programação poderosa que oferece muitos recursos avançados de programação, mas você não precisa usar nenhum deles ao escrever código Spark. As estruturas complexas de processamento de dados do Spark podem ser construídas com recursos básicos da linguagem Scala, como object, ife <em>funções</em>. O Scala também é ótimo para programação Spark de nível inferior</p><p>Acredito que a melhor linguagem para sua organização ou para seu projeto, dependerá muito do conhecimento de sua equipe. Plataformas como Databricks facilitam a escrita de trabalhos em ambas linguagens.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=793e0bc32ca5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Os problemas de desempenho mais comuns ao usar o Spark — Parte 2.]]></title>
            <link>https://medium.com/@juancaio/os-problemas-de-desempenho-mais-comuns-ao-usar-o-spark-parte-2-63267665ae74?source=rss-f6b51ceba38c------2</link>
            <guid isPermaLink="false">https://medium.com/p/63267665ae74</guid>
            <category><![CDATA[big-data-analysis]]></category>
            <category><![CDATA[spark]]></category>
            <category><![CDATA[pyspark]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[big-data-analytics]]></category>
            <dc:creator><![CDATA[Juan Caio]]></dc:creator>
            <pubDate>Tue, 14 Feb 2023 22:54:44 GMT</pubDate>
            <atom:updated>2023-02-14T22:55:54.998Z</atom:updated>
            <content:encoded><![CDATA[<h3>Os problemas de desempenho mais comuns ao usar o Spark — Parte 2.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aSKBwC65j7BfmmOwenn00g.jpeg" /><figcaption><a href="https://br.freepik.com/fotos-gratis/chama-de-fogo-em-fundo-preto_16263289.htm#query=spark&amp;position=1&amp;from_view=search&amp;track=sph">Imagem de rawpixel.com</a> no Freepik</figcaption></figure><p>No meu último artigo, eu escrevi um pouco sobre os principais problemas de desempenho ao usar o Spark, bom esse artigo aqui será uma continuação do primeiro, nessa parte 2, vamos tratar sobre o que podemos fazer para evitar ou diminuir esses problemas.</p><h3>Spill</h3><p>O que podemos fazer para mitigar o Spill ?</p><ul><li>A maneira mais fácil e cara é alocar um cluster com mais memória por worker.</li><li>Em caso de Spill causado por desvio, trate o desvio e o Spill será resolvido.</li><li>Diminuir o tamanho de cada partição aumentando o número de partições, e como podemos fazer isso?</li></ul><p>=&gt; Gerenciando <em>spark.sql.shuffle.partitions.</em></p><p>=&gt; Ao repartir explicitamente.</p><p>=&gt; Gerenciando <em>spark.sql.files.maxPartitionBytes.</em></p><p>Para saber mais sobre esse</p><h3>Skew</h3><p>O que podemos fazer para mitigar o Skew?</p><ul><li>O primeiro problema que precisamos resolver é a distribuição desigual de registros em todas as partições, o que resulta em tarefas mais lentas.</li><li>Mitigar o problema de RAM que causa erros de spill ou falta de memória pode apenas corrigir os sintomas, mas não a causa raiz.</li></ul><p>Estratégias para corrigir o skew:</p><ul><li>Ative a execução da Adaptive Query se estiver usando o Spark 3, que equilibrará as partições para os nós automaticamente, o que é um recurso muito bom do Spark 3.</li><li>Empregar uma skew-hint. Com as informações dessas hints, o Spark pode construir um plano de consulta melhor, que não sofra de distorção de dados.</li><li>Salt a coluna distorcida com um número aleatório, criando uma melhor distribuição em cada partição com o custo de processamento extra.</li></ul><p>Aqui você pode ler mais sobre o assunto: <a href="https://www.databricks.com/blog/2020/05/29/adaptive-query-execution-speeding-up-spark-sql-at-runtime.html">https://www.databricks.com/blog/2020/05/29/adaptive-query-execution-speeding-up-spark-sql-at-runtime.html</a></p><p><a href="https://docs.databricks.com/optimizations/skew-join.html">https://docs.databricks.com/optimizations/skew-join.html</a></p><h3>Shuffle</h3><p>O que podemos fazer para atenuar os problemas de desempenho causados ​​pelo Shuffle?</p><ul><li>Nossa estratégia número um é reduzir o I/O de rede usando menos e mais workers. Quanto maior a máquina e quanto menos máquinas tivermos, menos dados teremos para mover entre essas máquinas. Ainda incorreremos no I/O do disco, mas com menos máquinas, reduziremos significativamente o I/O da rede.</li><li>A próxima estratégia é reduzir a quantidade de dados sendo embaralhados como um todo. Algumas das coisas que podemos fazer são: livrar-se das colunas que você não precisa, filtrar registros desnecessários, otimizar a ingestão de dados.</li><li>Desnormalize os conjuntos de dados especificamente se o shuffle for causado por uma join.</li><li>Se você estiver unindo tabelas, poderá empregar um <em>BroadcastHashJoin</em>, caso em que a menor das duas tabelas será redistribuída para os executores para evitar totalmente a operação de shuffle. Isso é controlado pela propriedade <em>spark.sql.autoBroadcastJoinThreshold</em> (a configuração padrão é 10 MB). Se a menor das duas tabelas atingir o limite de 10 MB, poderemos transmiti-la.</li><li>Para joins, embaralhe previamente os dados com um conjunto de dados agrupado. O objetivo é eliminar a troca e classificação pré-embaralhando os dados. Os dados são agregados em N baldes e opcionalmente classificados e o resultado é salvo em uma tabela e disponível para leituras subsequentes.</li></ul><p>Aqui voce pode ler mais sobre o assunto:</p><p><a href="https://www.databricks.com/session_na20/on-improving-broadcast-joins-in-apache-spark-sql">On Improving Broadcast Joins in Apache Spark SQL - Databricks</a></p><p><a href="https://kb.databricks.com/data/bucketing.html">https://kb.databricks.com/data/bucketing.html</a></p><h3>Storage</h3><ul><li>Evitar manipulação de arquivos de partição com menos de 128 MB.</li><li>Ao varrer diretórios, podemos ter uma longa lista de arquivos em um único diretório ou, no caso de conjuntos de dados altamente particionados, pastas de vários níveis. Para reduzir a quantidade de leitura, podemos registra o <em>DataFrame</em> como uma tabela.</li><li>Dependendo do formato de arquivo usado, pode haver diferentes problemas de esquema. Por exemplo, usando JSON e CSV, todos os dados precisam ser lidos para inferir tipos de dados. Para o Parquet, apenas uma única leitura de arquivo é necessária, mas toda a lista de arquivos do Parquet precisa ser lida se precisarmos lidar com possíveis alterações de esquema ao longo do tempo. Para melhorar o desempenho, pode ser útil fornecer definições de esquema com antecedência.</li></ul><h3>Serialization</h3><ul><li>Problemas de serialização podem surgir ao integrar bases de código com sistemas legados (por exemplo, Hadoop), bibliotecas de terceiros e estruturas personalizadas. Uma abordagem importante que podemos adotar para reduzir os problemas de serialização é evitar o uso de UDFs ou UDFs vetorizados (que agem como uma caixa preta para o Catalyst Optimizer).</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=63267665ae74" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Os problemas de desempenho mais comuns ao usar o Spark — Parte 1.]]></title>
            <link>https://medium.com/@juancaio/os-problemas-de-desempenho-mais-comuns-ao-usar-o-spark-392c5954628f?source=rss-f6b51ceba38c------2</link>
            <guid isPermaLink="false">https://medium.com/p/392c5954628f</guid>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[big-data-analytics]]></category>
            <category><![CDATA[data-engineer]]></category>
            <category><![CDATA[spark]]></category>
            <dc:creator><![CDATA[Juan Caio]]></dc:creator>
            <pubDate>Sun, 29 Jan 2023 02:41:22 GMT</pubDate>
            <atom:updated>2023-02-14T22:56:43.838Z</atom:updated>
            <content:encoded><![CDATA[<p>O Apache Spark é atualmente uma das tecnologias de big data mais popular e mais utilizada no mercado. Uma das principais responsabilidades dos engenheiros de dados ao usar o Spark é escrever código altamente otimizado para aproveitar totalmente os recursos da computação distribuída.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/886/1*rMhuy_mtJc0dJXZ6LvLdxw.png" /></figure><p>Os 5 principais problemas de desempenho mais comuns no Spark são: Spill, Skew, Shuffle, Storage e Serialization.</p><h3>Spill</h3><p>A maneira mais fácil de pensar sobre o spill é que, para cada tarefa, há uma partição correspondente e, se essa tarefa não puder processar essa partição com memória alocada para armazenar essa partição específica, os dados que representam a partição serão gravados no disco e lidos de volta.</p><p>Spill é o termo usado para se referir ao ato de mover um RDD da RAM para o disco e, posteriormente, de volta à RAM novamente.</p><p>Isso ocorre quando uma determinada partição é simplesmente muito grande para caber na RAM. A consequência disso é que o Spark é forçado a leituras e gravações de disco caras para liberar RAM local para evitar o erro de falta de memória, que pode travar o aplicativo.</p><h3>Skew</h3><p>No Spark, os dados do cluster normalmente são lidos como partições de 128MB, o que garante uma distribuição uniforme dos dados. No entanto, como os dados são transformados, é possível ter significativamente mais registros em uma partição do que em outra. Essa distribuição significativamente desigual de registros em partições é chamada de Skew.</p><p>Skew é o resultado do desequilíbrio de tamanho entre as diferentes partições. Pequenas quantidades de Skew podem ser perfeitamente aceitáveis, mas em algumas circunstancias, Skew pode resultar em erros de Spill e OOM.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/886/1*UY91CC8o2vcLwH3SgWJmHQ.png" /></figure><h3>Shuffle</h3><p>O Spark processa consultas distribuindo dados por vários nós e calculando os valores separadamente em cada nó. No entanto, ocasionalmente, os nós precisam trocar os dados, afinal, esse é o proposito do Spark, processar dados que não cabem em uma única máquina.</p><p>Shuffle é o processo de troca de dados entre as partições, como resultado, as linhas de dados podem se mover entre os nós do worker quando sua partição de origem e a partição de destino residem em uma máquina diferente.</p><p>O Spark não move dados entre os nós de forma aleatória. O shuffle é uma operação demorada e muito custosa, por isso só acontece quando não há outra opção.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/886/1*thS73NR3rs6vQ0JvBUzpEA.png" /></figure><h3>Storage</h3><p>Os problemas de armazenamento surgem quando os dados são armazenados no disco de maneira não otimizada. Problemas relacionados ao armazenamento podem causar Shuffle excessivo. Três dos principais problemas associados ao armazenamento são: arquivos minúsculos, scanning e schemas.</p><h3>Serialization</h3><p>A serialização abrange todos os problemas associados à distribuição de código entre clusters.</p><p>No caso do Python, esse processo pode ser ainda mais complicado, pois o código deve ser decapado e uma instância do interpretador Python deve ser alocada para cada executor.</p><p><a href="https://en.wikipedia.org/wiki/Serialization"><strong>A serialização</strong></a><strong> </strong>refere-se à conversão de objetos em um fluxo de bytes e vice-versa de uma maneira ideal para transferi-los pelos nós da rede ou armazená-los em um buffer de arquivo/memória.</p><p>O Spark fornece duas bibliotecas de serialização: <a href="https://www.baeldung.com/java-serialization">Serialização Java</a> e <a href="https://medium.com/@knoldus/kryo-serialization-in-spark-55b53667e7ab">Serialização Kryo</a>.</p><p>Continuação: <a href="https://medium.com/@juancaio/os-problemas-de-desempenho-mais-comuns-ao-usar-o-spark-parte-2-63267665ae74">https://medium.com/@juancaio/os-problemas-de-desempenho-mais-comuns-ao-usar-o-spark-parte-2-63267665ae74</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=392c5954628f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Porque utilizar o teste de unidade em seu código PySpark?]]></title>
            <link>https://medium.com/@juancaio/porque-utilizar-o-teste-de-unidade-em-seu-c%C3%B3digo-pyspark-4adb7e94457d?source=rss-f6b51ceba38c------2</link>
            <guid isPermaLink="false">https://medium.com/p/4adb7e94457d</guid>
            <category><![CDATA[pyspark]]></category>
            <category><![CDATA[data-engineer]]></category>
            <category><![CDATA[test]]></category>
            <category><![CDATA[code-quality]]></category>
            <category><![CDATA[code-quality-tools]]></category>
            <dc:creator><![CDATA[Juan Caio]]></dc:creator>
            <pubDate>Fri, 30 Dec 2022 18:55:44 GMT</pubDate>
            <atom:updated>2022-12-30T18:55:44.783Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*MwZZjt-IlJU0TFaZxfBz1Q.jpeg" /></figure><p>O teste de unidade em qualquer tipo de código vai conseguir te ajudar a melhorar a qualidade e a consistência do seu código. O teste de unidade é uma abordagem para testar unidades de código independentes, como funções, antecipadamente e com frequência. Isso ajuda a você a encontrar problemas com o seu código mais rapidamente, descobrir suposições equivocadas, além de te ajudar na manutenção do seu projeto e simplificar seus esforços gerais de codificação, pois quanto mais cedo você encontra o bug por menos tempo ele vai te dar dor de cabeça.</p><h3>Conhecendo o Chispa</h3><p>O <a href="https://github.com/MrPowers/chispa">Chispa</a> é uma biblioteca Python que fornece métodos auxiliares de teste Pyspark, de forma rápida, com a cobertura adequada do seu código e com mensagens de erros descritivas e intuitivas, que facilita seu fluxo de trabalho de desenvolvimento. Essa biblioteca facilita a criação de códigos PySpark de alta qualidade.</p><p>Um conjunto de testes robustos facilita a adição de novos recursos e a refatoração de seu código. Ele também fornece a outros desenvolvedores uma “documentação de código viva”, o que ajuda na manutenção do seu código.</p><h3>Instalação</h3><p>Para instalar o Chispa é bem simples:</p><pre>pip install chispa</pre><h3>Alguns exemplos de teste de unidade com o Chispa:</h3><p>Suponha que temos uma função que faz uma deleção de linhas duplicadas.</p><pre>def drop_duplicates(df:DataFrame, col_order: str, cols_partition:List[Any]) -&gt; DataFrame:<br>    &quot;&quot;&quot;Function that performs the deletion of duplicate data according to key columns.<br>    Args:<br>        df (DataFrame): DataFrame.<br>        col_order (str): Column to be used in sorting.<br>        cols_partition (list): List of key columns, for partitioning.<br>    Returns:<br>        DataFrame: DataFrame without the duplicate data, according to the key columns.<br>        <br>    Example:<br>        &gt;&gt;&gt; cols = [&#39;longitude&#39;,&#39;latitude&#39;]<br>        &gt;&gt;&gt; df = drop_duplicates(df, &#39;population&#39;, cols)<br>    &quot;&quot;&quot;<br>    win = Window.partitionBy(cols_partition).orderBy(F.col(col_order).desc())<br>    return df.withColumn(&quot;col_rank&quot;, F.row_number().over(win)).filter(F.col(&#39;col_rank&#39;) == 1).drop(&#39;col_rank&#39;)</pre><p>Podemos realizar um teste para realmente verificar se os registros duplicados foram devidamente excluído.</p><pre>import pytest<br>from chispa.dataframe_comparer import assert_df_equality<br><br>def test_drop_duplicates() -&gt; None:<br>    &quot;&quot;&quot;Test to check if the duplicates are dropped.&quot;&quot;&quot;    <br>    source_data = [<br>            (&#39;jose&#39;, &#39;1&#39;, &#39;BA&#39;),<br>            (&#39;jose&#39;, &#39;2&#39;, &#39;BA&#39;),<br>            (&#39;maria&#39;, &#39;3&#39;, &#39;PA&#39;),<br>            (&#39;joao&#39;, &#39;4&#39;, &#39;RJ&#39;)<br>    ]<br><br>    source_df = spark.createDataFrame(source_data, [&#39;name&#39;, &#39;index&#39;, &#39;state&#39;])<br><br>    actual_df = drop_duplicates(source_df, &#39;index&#39;, [&#39;name&#39;, &#39;state&#39;])<br><br>    expected_data = [<br>            (&#39;jose&#39;, &#39;2&#39;, &#39;BA&#39;),<br>            (&#39;maria&#39;, &#39;3&#39;, &#39;PA&#39;),<br>            (&#39;joao&#39;, &#39;4&#39;, &#39;RJ&#39;)<br>    ]<br><br>    expected_df = spark.createDataFrame(expected_data, [&#39;name&#39;, &#39;index&#39;, &#39;state&#39;])<br><br>    assert_df_equality(actual_df, expected_df)</pre><p>Algumas vezes, só com biblioteca <a href="https://docs.pytest.org/en/7.2.x/">pytest </a>você pode conseguir cobrir com qualidade toda a sua função.</p><p>Por exemplo, nesse caso aqui foi criada uma função que a partir de um DataFrame é criada uma lista.</p><pre>def create_col_list (df: DataFrame, col: str) -&gt; List[str]:<br>    &quot;&quot;&quot;Function that creates a list with unique values from a column.<br>    Args:<br>        df (DataFrame): DataFrame.<br>        col (str): Column that will become a list.<br>    Returns:<br>        list: A list of unique values for a given DataFrame column.<br>        <br>    Example:<br>        &gt;&gt;&gt; create_col_list(df, &#39;city&#39;)<br>    &quot;&quot;&quot;<br>    return [str(value) for value in df.select(col).distinct().rdd.flatMap(lambda x:x).collect()]</pre><p>Nesse caso conseguimos criar uma cobertura de teste, somente utilizando o pytest, segue exemplo:</p><pre>import pytest<br><br>def test_create_col_list() -&gt; None:<br>    &quot;&quot;&quot;Test to check if the column list is created correctly.&quot;&quot;&quot;    <br>    source_data = [<br>            (&#39;jose&#39;, 21, &#39;BA&#39;),<br>            (&#39;jose&#39;, 11, &#39;BA&#39;),<br>            (&#39;maria&#39;, 32, &#39;PA&#39;),<br>            (&#39;joao&#39;, 44, &#39;RJ&#39;)<br>    ]<br><br>    source_df = spark.createDataFrame(source_data, [&#39;name&#39;, &#39;age&#39;, &#39;state&#39;])<br><br>    actual_list = create_col_list(source_df, &#39;name&#39;)<br><br>    expected_list = [&#39;jose&#39;, &#39;joao&#39;,&#39;maria&#39;]<br>    assert actual_list == expected_list</pre><p>Nesse link <a href="https://github.com/MrPowers/chispa">aqui</a> você vai poder ver muitos outros exemplos de como utilizar o Chispa e de como ele pode te ajudar no desenvolvimento de códigos mais seguros, confiáveis e com qualidade.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4adb7e94457d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como obter as métricas do Spark com o SparkMeasure]]></title>
            <link>https://medium.com/@juancaio/como-obter-as-m%C3%A9tricas-do-spark-com-o-sparkmeasure-a7d8ea05a183?source=rss-f6b51ceba38c------2</link>
            <guid isPermaLink="false">https://medium.com/p/a7d8ea05a183</guid>
            <category><![CDATA[spark]]></category>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[engenharia-de-dados]]></category>
            <category><![CDATA[ambev]]></category>
            <dc:creator><![CDATA[Juan Caio]]></dc:creator>
            <pubDate>Fri, 16 Dec 2022 21:21:01 GMT</pubDate>
            <atom:updated>2022-12-16T21:21:01.214Z</atom:updated>
            <content:encoded><![CDATA[<p>Muitas vezes queremos entender melhor o desempenho e a performance do nosso código Spark e nem sempre medir o fator tempo vai ser capaz de dizer se o nosso código é realmente eficiente. Diante disso surgi o SparkMeasure que é uma ferramenta para investigação de problemas de desempenho em Jobs do Apache Spark, ele simplifica a coleta e análise de métricas de desempenho do Spark.<br>Você pode utilizar o SparkMeasure para:</p><ul><li>Investigar problemas de cargas de Jobs interativos e em lote do Spark.</li><li>Coletar métricas para retenção de longo prazo ou como parte de um pipeline de CI/CD.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/567/1*gUu2P0dqsxv3-34mxRYb3Q.png" /><figcaption>Arquitetura mostrando o funcionamento do SparkMeasure</figcaption></figure><h4>Principais conceitos subjacentes ao SparkMeasure</h4><ul><li>As métricas podem ser coletadas usando sparkMeasure na granularidade da conclusão do stage e/ou conclusão da task.</li><li>As métricas são achatadas e coletadas em estruturas de memória local no driver (ListBuffer de uma classe de caso personalizada).</li><li>Spark DataFrame e SQL são usados para processar ainda mais dados de métricas, por exemplo, para gerar relatórios.</li><li>Dados de métricas e relatórios podem ser salvos para análise offline.</li></ul><p><strong>Por que medir o desempenho com instrumentação de métricas de carga de job em vez de apenas usar o fator tempo?</strong></p><ul><li>Medir o tempo decorrido trata sua carga de job como “uma caixa preta” e na maioria das vezes não permite que você entenda a causa raiz do desempenho. Com as métricas das cargas dos Jobs você pode tentar ir mais longe na compreensão e análise de causa raiz, identificação de gargalos, medição de uso de recursos.</li></ul><p><strong>O que são as métricas das tasks do Apache Spark e para que posso usá-las?</strong></p><ul><li>O Apache Spark mede vários detalhes da execução de cada tarefa, incluindo tempo de execução, tempo de CPU, informações sobre tempo de garbage collect, métricas de shuffle e I/O de tasks.</li></ul><p>Principais métricas:</p><ul><li><strong>executorRunTime</strong> — Tempo decorrido que o executor gastou executando esta tarefa. Isso inclui o tempo de busca de dados aleatórios. O valor é expresso em milissegundos.</li><li><strong>executorCpuTime</strong> — Tempo de CPU que o executor gastou executando esta tarefa. Isso inclui o tempo de busca de dados aleatórios. O valor é expresso em nanossegundos.</li><li><strong>resultSize</strong> — O número de bytes que esta tarefa transmitiu de volta ao driver como o TaskResult.</li><li><strong>jvmGCTimeName</strong> — Tempo decorrido que a JVM gastou na coleta de lixo durante a execução desta tarefa. O valor é expresso em milissegundos.</li><li><strong>memoryBytesSpilled</strong> — O número de bytes na memória derramados por esta tarefa.</li></ul><p>Consulte também a <a href="https://spark.apache.org/docs/latest/monitoring.html#executor-task-metrics">documentação do Spark</a> para obter uma descrição das outras métricas.</p><p><strong>Quando devo usar métricas do stage e quando devo usar métricas da task?</strong></p><ul><li>Use métricas do stage sempre que possível, pois elas são muito mais leves. Colete métricas na granularidade da task se precisar de informações extras, por exemplo, se quiser estudar efeitos da inclinação, caudas longas e atrasos na tarefa.</li></ul><p><strong>O que são acumuláveis?</strong></p><ul><li>As métricas são primeiro coletadas em acumuladores que são enviados dos executores para o driver. Muitas métricas de interesse são expostas por meio de [[TaskMetrics]] outras estão disponíveis apenas em acumuláveis StageInfo/TaskInfo (principalmente Métricas SQL, como “tempo de verificação”).</li></ul><p><strong>Como posso processar dados das métricas?</strong></p><ul><li>Você pode usar o Spark para ler os dados de métricas salvos e realizar mais pós-processamento e análise. Consulte também esse <a href="https://github.com/LucaCanali/sparkMeasure/blob/master/docs/Notes_on_metrics_analysis.md">link</a>.</li></ul><p>Alguns exemplos da aplicação: <a href="https://databricks-prod-cloudfront.cloud.databricks.com/public/4027ec902e239c93eaaa8714f173bcfc/2061385495597958/3856830937265976/442806354506758/latest.html">Databricks</a> e <a href="https://colab.research.google.com/github/LucaCanali/sparkMeasure/blob/master/examples/SparkMeasure_Jupyter_Colab_Example.ipynb">Colab</a>.</p><p>Código de exemplo:</p><pre>from pyspark.sql import Window, SparkSession, functions as F<br>from sparkmeasure import TaskMetrics, StageMetrics<br><br>spark = SparkSession \<br> .builder \<br> .master(&quot;local[*]&quot;) \<br> .appName(&quot;Test sparkmeasure&quot;) \<br> .config(&quot;spark.jars.packages&quot;,&quot;ch.cern.sparkmeasure:spark-measure_2.12:0.22&quot;)  \<br> .getOrCreate()<br><br>taskmetrics = TaskMetrics(spark)<br>taskmetrics.begin()<br><br>df = spark.read.parquet(&#39;/pasta/teste/sparkmeasure/&#39;)<br>df = df.select(&#39;document&#39;, &#39;client&#39;, &#39;value&#39;, &#39;channel&#39;, &#39;year&#39;).dropDuplicates([&#39;document&#39;])<br>df.count()<br><br>taskmetrics.end()<br>taskmetrics.print_report()</pre><p>Print com os resultados das métricas:</p><pre>Scheduling mode = FAIR<br>Spark Contex default degree of parallelism = 24<br>Aggregated Spark task metrics:<br>numtasks =&gt; 746<br>elapsedTime =&gt; 874599 (15 min)<br>duration =&gt; 20108557 (5.6 h)<br>schedulerDelayTime =&gt; 4385 (4 s)<br>executorRunTime =&gt; 20101174 (5.6 h)<br>executorCpuTime =&gt; 143365 (2.4 min)<br>executorDeserializeTime =&gt; 2741 (3 s)<br>executorDeserializeCpuTime =&gt; 2329 (2 s)<br>resultSerializationTime =&gt; 257 (0.3 s)<br>jvmGCTime =&gt; 98780 (1.6 min)<br>shuffleFetchWaitTime =&gt; 208 (0.2 s)<br>shuffleWriteTime =&gt; 9505 (10 s)<br>gettingResultTime =&gt; 0 (0 ms)<br>resultSize =&gt; 149828 (146.0 KB)<br>diskBytesSpilled =&gt; 0 (0 Bytes)<br>memoryBytesSpilled =&gt; 0 (0 Bytes)<br>peakExecutionMemory =&gt; 570425344<br>recordsRead =&gt; 6931280<br>bytesRead =&gt; 823377246 (785.0 MB)<br>recordsWritten =&gt; 6055732<br>bytesWritten =&gt; 444583555 (423.0 MB)<br>shuffleRecordsRead =&gt; 19000940<br>shuffleTotalBlocksFetched =&gt; 3660<br>shuffleLocalBlocksFetched =&gt; 1196<br>shuffleRemoteBlocksFetched =&gt; 2464<br>shuffleTotalBytesRead =&gt; 1953231182 (1862.0 MB)<br>shuffleLocalBytesRead =&gt; 788920076 (752.0 MB)<br>shuffleRemoteBytesRead =&gt; 1164311106 (1110.0 MB)<br>shuffleRemoteBytesReadToDisk =&gt; 0 (0 Bytes)<br>shuffleBytesWritten =&gt; 1017238808 (970.0 MB)<br>shuffleRecordsWritten =&gt; 12966110</pre><p>Criando um dataframe com o resultado das metricas:</p><pre>df_metrics = taskmetrics.aggregate_taskmetrics_DF(&#39;PerfTaskMetrics&#39;)</pre><p><strong>Conclusão</strong></p><p>O SparkMeasure é uma ferramenta bastante poderosa e que pode ajudar tanto no monitoramento como na avaliação dos seus códigos. Você pode por exemplo criar um dashboard com informações das métricas de forma temporal, para que assim você consiga ter uma noção do desempenho das suas execuções. Esse tipo de dado é precioso para visualizar e entender as causas principais dos problemas de desempenho dos seus processos.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a7d8ea05a183" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>