zoukankan      html  css  js  c++  java
  • spark笔记01

    day7
    
    
    hadoop 离线数据分析 批量;
    
    spark 
    
    
    
    【spark】
    
    * 环境配置:
        安装spark - Local本地模式  ok
    * spark学习
        @Scala环境:
            1 shell交互环境
                启动:spark-shell;(默认进入且自带):
                命令学习:
                    实验案例:
                        1 wordcount:
                            textFile("input"):读取本地文件input文件夹数据;
                            flatMap(_.split(" ")):压平操作,按照空格分割符将一行数据映射成一个个单词;
                            map((_,1)):对每一个元素操作,将单词映射为元组;
                            reduceByKey(_+_):按照key将值进行聚合,相加;
                            collect:将数据收集到Driver端展示。
    
                    *** RDD:
                        1 RDD认识:
                            概念认知:
                                分布式对象集合;
                                本质上是一个只读的分区记录集合,每个RDD可以分成多个分区,
                                每个分区就是一个数据集片段,
                                并且一个RDD的不同分区可以被保存到集群中不同的节点上,
                                从而可以在集群中的不同节点上进行并行计算
                                弹性数据集;
                                    RDD提供了一种高度受限的共享内存模型????;
                                    RDD提供了一组丰富的操作以支持常见的数据运算;
                                只读
                            操作理解:
                                创建:
                                转换:理解 - 输入RDD,输出RDD;存在“父子”依赖关系 具体:父子RDD分区的对应关系;
                                行动:理解 - 输入RDD,输出值;
                            官方性名词理解:
                                
                                分区:
                                    逻辑上是分区
                                算子:
                                    理解:一系列操作 transformations&actions;
                                          目标 - 一个RDD转成另一个RDD;
                                
                                依赖:
                                    一个RDD转成另一个RDD时,有联系;
                                    窄依赖:RDDs之间分区是一一对应的 / 多(父RDD)对一(子RDD)
                                    宽依赖:下游RDD的每个分区与上游RDD(也称之为父RDD)的每个分区都有关,是多对多的关系;
                                   (窄宽-理解:依据分区的对应关系分类)
    
                                缓存:
                                    目的:方便RDD重用;
                                
                                checkpoint
                                    问题:对于长时间迭代型应用,血缘关系越来越长,一旦在后续迭代过程中出错,
                                          则需要通过非常长的血缘关系去重建,影响性能
                                    目的:容错
                                    实现:将数据保存到持久化的存储,切断血缘关系,直接在checkpoint处拿数据;
                                
                                任务划分
                                    Application,Job,Stage,Task;
                                    Application->Job->Stage-> Task每一层都是1对n的关系
                                    划分阶段(1-21 根据依赖关系可构架一个DAG;
                                        2 反向解析,存在宽依赖,就划开阶段
                                        3 任务集:每个阶段都代表了一组关联的、相互之间没有Shuffle依赖关系的任务组成的任务集合
                                                  每个任务会被任务调度器分发给各个工作节点(Worker Node)上的Executor去执行
                        2 RDD实践:
                            
                            Lamda 表达式;??????????????? 我好难啊
                        
                            tuple 元组<key,value>;
                            
                            RDD:也是Map+reduce思路;
                            flatMap(将一个一个小集合合成一个大集合) 
                            Map:
                            Reduce:
                            
                            RDD transformations:
                                Value类型
                                    partitions.size;:查看RDD的分区数
                                    map();
                                    mapPartitions();
                                    mapPartitionsWithIndex();
                                    flatMap();
                                    glom()
                                    groupBy();
                                    filter();
                                    sample(withReplacement,fraction,seed);
                                    distinct([numTasks]);
                                    coalesce(numPartitions);
                                    repartition(numPartitions);
                                    sortBy(func,[ascending], [numTasks]);
                                双Value类型交互:源RDD & 参数RDD
                                    union(otherDataset);
                                    subtract(otherDataset);
                                    intersection(otherDataset);
                                    cartesian(otherDataset);笛卡尔积-> 生成一系列元组<a,b>
                                    zip(otherDataset);
                                Key-Value类型
                                    partitionBy();
                                    groupByKey();
                                    reduceByKey(func, [numTasks]);
                                    aggregateByKey();?
                                    foldByKey();
                                    combineByKey();?
                                    sortByKey([ascending], [numTasks]);
                                    mapValues();
                                    join(otherDataset, [numTasks]);
                                    cogroup(otherDataset, [numTasks]);
                            RDD Action
                                reduce(func);
                                collect();
                                count();
                                first();
                                take(n);
                                takeOrdered(n);
                                aggregate;
                                fold(num)(func);
                                saveAsTextFile(path);
                                saveAsSequenceFile(path) ;
                                saveAsObjectFile(path);
                                countByKey();
                                foreach(func);
                        RDD总结:
                            1 解决了什么?
                                实现(对大型数据集)高效计算;    
                            2 怎么实现?
                                ?
                                
            
            2 spark独立应用程序(注:支持java,scala,python)
                * scala:
                    方式一 - 手动构建:
                        Scala编译打包工具sbt + 构建项目目录结构 + 编写核心代码文件 -> 打包成jar;
                    方式人 - 编译器:
    
                * java:
                    方式一 - 手动构建:
                        java打包工具Maven+ 构建maven项目 -> 打包成jar;
                    方式人 - 编译器:
                        
                    
            
            
        @Python环境:
            0 配置与pyspark相关文件;
            1 shell交互环境
                启动:pyshpark;
                
                
                
    
    
    【new】
    
    问题1:在linux下转移文件到 /usr/local/....后需要 命令加sudo才可以执行;
    方式:更改文件所有者 chown -R  kouch:kouch(当前用户)  **** ;
    ...................................................
  • 相关阅读:
    编译安装
    yum history使用详解(某次为解决误卸载软件的回退实验)
    centos7了解
    码云仓库中获取单个文件的超链接
    常用软件及安装目录有链接的
    rsync备份服务器部署详情
    snmpwalk命令详解
    vmware迁移虚拟机
    ngrinder脚本请求头中添加cookie后仍报未登录或者401错误问题解决
    python多进程和多线程效率比较,ProcessPoolExecutor,ThreadPoolExecutor
  • 原文地址:https://www.cnblogs.com/floakss/p/11525910.html
Copyright © 2011-2022 走看看