Python Brasil 2016 - PySpark Tutorial

Transcript

1. pyspark e computação distribuída @bsao / hello@bsao.me
2. @bsao • +13 anos como desenvolvedor (+10 com python) • senior data engineer @ vivareal.com • contratando muito: https://jobs.lever.co/vivareal/ rupy brazil chairman startup vale co-founder agilevale co-founder
3. enquanto isso jre +1.7 http://spark.apache.org/ downloads > 1.6,2 pre built with hadoop 2.4
4. https://github.com/ bsao/pybr12-tutorial/
5. big data é o imenso volume de dados estruturados ou não que impactam o dia a dia dos negócios.
6. 5 “v’s” volume velocidade variedade valor veracidade
7. http://cacm.acm.org/blogs/blog-cacm/169199-data-science-workflow-overview-and-challenges/fulltext
8. Computação Distribuida • Problemas de big data não podem ser resolvidos apenas em um computador; • Paralelizar; • Distribuir; • Processar mais dado em menos tempo;
9. Desafios 1. Falhas de Hardware; 2. Particionamento dos Dados; 3. Comunicação entre as maquinas e processos; 4. Escalonagem;
10. Falhas de Hardware • Falhas de Energia; • Falhas de Memória; • Falhas na Rede; • Falhas no Disco;
11. Particionamento • Como dividir os dados em cada computador? • Como manter os dados que fazem sentido de serem processados juntos? • Divisão de carga entre os processo, ou seja, qual a carga de dados que cada computador vai executar? • Se hover “desbalanceio", a computação atrasa; • A computação só termina quando todos os processos estão finalizados;
12. Comunicação entre Maquinas e Processos • Latência da Rede & Envio de mensagens; • Comunicação dos resultados parciais;
13. Escalonamento • Quem vai executar o que? • Qual a ordem de execução? • Sincronização;
14. TRUCO • Modelos de computação distribuída servem para isso; • MapReduce; • Spark;
15. +
16. • framework para processamento de big-data • foco em velocidade • abstração de analises sofisticadas • nasceu da academia em Berkeley, 2009 • open source 2010 • fácil/rápido/escalável/framework para cluster computing • o core é escrito em scala (jvm) • apis completas para Python e o resto (Java/Scala/R) • um projeto muito ativo desde 2014
17. características • extende MapReduce; • suporta mais do que apenas as funções de Map e Reduce; • evita mover dados durante o processamento, • “cachea” dados em memória e processamento proximo do tempo real. • detem dados intermediários em memória, para processar o mesmo conjunto de dados varias vezes • o disco é usado quando a memória acaba. • REPL
18. creditos: https://weidongzhou.wordpress.com/2015/09/08/hadoop-hdfs-mapreduce-and-spark-on-big-data/
19. arquitetura • API - criação de aplicações (Scala, Java ou Python) • Armazenamento de dados - Usa o HDFS para armezar os dados, ou seja, consegue processar nativamente qualquer dado compatível. • Framework de gerenciamento - Gestão da infraestrutura.
20. RDD Resilient Distributed Datasets é a estrutura de dado fundamental do Spark é uma coleção de dados distribuida pode conter qualquer tipo de dados python / java ou scala tolerante a falhas
21. SparkContext • é a porta de entrada para o spark • configuração e provisionamento
22. RDD storage valor tranformacão map filter foreach group ação count take reduce collect countByValue savar
23. modelo de execução Driver SparkContext Worker Executor Task Worker Executor Task Worker Executor Task
24. beatles = sc.textFile(‘storage/file’) storage partição partição partição beatles = beatles.map(loads) collect beatles.collect() partição partição partição beatles = beatles.filter(lambda b: b[‘track_duration’] > 25000)
25. behind the scenes - python • py4j - permite que um programa python rodando dentro de um interpretador python possa acessar objetos java em uma jvm. • pickle
26. driver worker Python SparkContext beatles = sc.textFile(‘storage/file’) py4j Java SparkContext sc = SparkContext() java executor task beatles = beatles.map(loads) Python Code Python Code task beatles = beatles.filter(lambda b: b[‘track_duration’] > 25000)
27. funções serão executadas no worker por um processo python
28. spark permite criar programas altamente testavéis
29. http://spark.bsao.me:8888/
30. let’s start • ./bin/pyspark
31. SparkContext • o SparkContext é a porta de entrada de tudo, diz ao PySpark como acessar o cluster Spark; • acesse a variável “sc"
32. parametro master local é o default, roda o spark localmente com uma worker thread (sem paralelismo) local[K] roda o spark com K worker threads (idealmente o numero de cores da maquina) spark://HOST:PORT conecta em um cluster spark, a porta default é 7077 mesos://HOST:PORT conecta em um cluster mesos, a porta default 5050
33. clusters • o master conecta no manager do cluster; • aloca recursos; • aloca executors; • envia o código da app para os executors;
34. persistencia dos dados • o Spark pode persistir (cache) os dados em memória; • cada maquina do cluster guarda pedaços dos dados e reusa em futuras operações, o que faz o Spark ser até 100x mais rápido em futuras operações; • o cache é tolerante a falhas, se qualquer maquina ou partição enfrentar problemas, será automaticamente recomputado;
35. MEMORY_ONLY guarda um RDD como um objeto deserializado em memoria na JVM, se o objeto não couber na memória, as partições que não couberem não serão armazenadas e serão recomputadas em tempo de execução; MEMORY_AND_DISK mesmo que o MEMORY_ONLY mas, se os dados não couberem na memória, serão persistidos em disco. MEMORY_ONLY_SER mesmo que o MEMORY_ONLY mas armazena um objeto serializado em memória. Tende a ser mais eficiente, mas consome mais CPU. MEMORY_AND_DISK_SER mesmo que MEMORY_ONLY_SER, mas, se os dados não couberem na memória, serão persistidos em disco. DISK_ONLY armazena somente em disco MEMORY_ONLY_2
 MEMORY_AND_DISK_2 exatamente mesma coisa que as informações acima, porem replica a partição em 2 nós.
36. from pyspark import StorageLevel rdd.persist(StorageLevel.MEMORY_AND_DISK_2).cache()
37. transformations map(f) aplica uma função para cada registro do rdd filter(f) filtra um rdd baseada em uma função flatMap(f) igual ao map, mas entrega uma collection flat union(rdd) une dois rdd's distinct() realiza um distinção de valores baseado em uma cahve groupByKey() agrega valores pela key de uma tupla reduceByKey(f) agrega uma rdd baseada em uma funcao com retorno de um key
38. sortByKey(f) ordena um rdd baseado em uma funcao que retorna bool. join(f) realiza a união de um rdd baseada em uma chave cogroup(rdd) agrupa sequencias baseada em uma chave
39. actions reduce(f) agrega um rdd baseado em uma função; f recebe dois argumentos e retorna um. collect() retorna todos elementos de rdd count() conta os elementos de um rdd first() primeiro registro do rdd take(n) retornar n valores do rdd saveAsTextFile(path) save o rdd para um arquivo texto
40. Broadcast • permite que uma variável seja armazenada em cada nó sem que elas sejam enviadas através das tasks; • para melhor eficiência da comunicação entre as maquinas;
41. bc = sc.broadcast(list(range(1, 4))) print(bc.value)
42. Accumulators • São contadores, que só podem ser somados; • Permitem soma e contagens eficientes em tarefas com paralelismo; • Permite tipos númericos ou collections; • Pode ser extendido; • SOMENTE O DRIVER CONSEGUE LER O ACCUMULADOR;
43. ac = sc.accumulator(0) rdd = sc.parallelize([1, 2, 3, 4]) def f(x): global ac ac += x rdd.foreach(f) print(ac.value)
44. Spark SQL • permite queries SQL sobre um RDD;
45. Parquet • formato de arquivo colunar do ecossistema hadoop; • Spark suporta nativamente leitura e escrita de parquet files preservando os esquemas do RDD; • Suporta DSL como RDD :)
46. @bsao / hello@bsao.me / r0bsao