精华内容
下载资源
问答
  • 分布式文件系统HDFS

    2020-08-04 08:33:27
    分布式文件系统HDFS分布式文件系统HDFS分布式文件系统HDFS 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. ...

    HDFS分布式文件系统HDFS

    1.HDFS概述

    Hadoop Distributed File System (HDFS)

    1 ) 分布式

    2)运行在廉价通用的电脑上

    3)高容错

    4)高吞吐量(high throughput)

    5 ) 适用大的数据集

    有一般的文件系统的功能: 有目录结构,存放的是文件或者文件夹,对外提供服务:创建、修改、删除、查看、移动等

    普通的文件系统是单机的

    分布式文件系统能够横跨多个机器

    2.HDFS设计目标

    Hardware Failure解决硬件故障
    Hardware failure is the norm rather than the exception. An HDFS instance may consist of hundreds or thousands of server machines, each storing part of the file system’s data. The fact that there are a huge number of components and that each component has a non-trivial probability of failure means that some component of HDFS is always non-functional. Therefore, detection of faults and quick, automatic recovery from them is a core architectural goal of HDFS.

    Streaming Data Access 数据流式访问
    Applications that run on HDFS need streaming access to their data sets. They are not general purpose applications that typically run on general purpose file systems. HDFS is designed more for batch processing rather than interactive use by users. The emphasis is on high throughput of data access rather than low latency of data access. POSIX imposes many hard requirements that are not needed for applications that are targeted for HDFS. POSIX semantics in a few key areas has been traded to increase data throughput rates.

    Large Data Sets大数据集
    Applications that run on HDFS have large data sets. A typical file in HDFS is gigabytes to terabytes in size. Thus, HDFS is tuned to support large files. It should provide high aggregate data bandwidth and scale to hundreds of nodes in a single cluster. It should support tens of millions of files in a single instance.

    Simple Coherency Model一致性模型
    HDFS applications need a write-once-read-many access model for files. A file once created, written, and closed need not be changed except for appends and truncates. Appending the content to the end of the files is supported but cannot be updated at arbitrary point. This assumption simplifies data coherency issues and enables high throughput data access. A MapReduce application or a web crawler application fits perfectly with this model.

    “Moving Computation is Cheaper than Moving Data” 移动计算比移动数据更划算
    A computation requested by an application is much more efficient if it is executed near the data it operates on. This is especially true when the size of the data set is huge. This minimizes network congestion and increases the overall throughput of the system. The assumption is that it is often better to migrate the computation closer to where the data is located rather than moving the data to where the application is running. HDFS provides interfaces for applications to move themselves closer to where the data is located.

    Portability Across Heterogeneous Hardware and Software Platforms跨平台
    HDFS has been designed to be easily portable from one platform to another. This facilitates widespread adoption of HDFS as a platform of choice for a large set of applications.

    3.HDFS架构详解

    1 NameNode and DataNodes

    2 HDFS has a master/slave architecture.

    3 NN(NameNode):An HDFS cluster consists of a single NameNode, a master server that manages the file system namespace and regulates access to files by clients.

    4 DN(DataNode):there are a number of DataNodes, usually one per node in the cluster, which manage storage attached to the nodes that they run on.

    5 HDFS exposes a file system namespace and allows user data to be stored in files

    6 Internally, a file is split into one or more blocks and these blocks are stored in a set of DataNodes.为了容错

    7 The NameNode executes file system namespace operations like opening, closing, and renaming files and directories.
    It also determines the mapping of blocks to DataNodes

    8 The DataNodes are responsible for serving read and write requests from the file system’s clients. The DataNodes also perform block creation, deletion, and replication upon instruction from the NameNode.

    在这里插入图片描述

    The NameNode and DataNode are pieces of software designed to run on commodity machines. These machines typically run a GNU/Linux operating system (OS).

    HDFS is built using the Java language; any machine that supports Java can run the NameNode or the DataNode software.

    Usage of the highly portable Java language means that HDFS can be deployed on a wide range of machines.

    A typical deployment has a dedicated machine that runs only the NameNode software. Each of the other machines in the cluster runs one instance of the DataNode software.

    The architecture does not preclude running multiple DataNodes on the same machine but in a real deployment that is rarely the case.

    4.文件系统NameSpace详解

    HDFS supports a traditional hierarchical file organization.

    A user or an application can create directories and store files inside these directories.

    The file system namespace hierarchy is similar to most other existing file systems; one can create and remove files, move a file from one directory to another, or rename a file.

    HDFS supports user quotas and access permissions.

    HDFS does not support hard links or soft links. However, the HDFS architecture does not preclude implementing these features.

    While HDFS follows naming convention of the FileSystem, some paths and names (e.g. /.reserved and .snapshot ) are reserved. Features such as transparent encryption and snapshot use reserved paths.

    The NameNode maintains the file system namespace.

    Any change to the file system namespace or its properties is recorded by the NameNode.

    An application can specify the number of replicas of a file that should be maintained by HDFS. 指定副本数

    The number of copies of a file is called the replication factor of that file. This information is stored by the NameNode.指定副本数

    5.HDFS副本机制

    HDFS is designed to reliably store very large files across machines in a large cluster.

    It stores each file as a sequence of blocks. The blocks of a file are replicated for fault tolerance.

    The block size and replication factor are configurable per file.

    All blocks in a file except the last block are the same size, while users can start a new block without filling out the last block to the configured block size after the support for variable length block was added to append and hsync.

    An application can specify the number of replicas of a file. The replication factor can be specified at file creation time and can be changed later. Files in HDFS are write-once (except for appends and truncates) and have strictly one writer at any time.

    The NameNode makes all decisions regarding replication of blocks. It periodically receives a Heartbeat and a Blockreport from each of the DataNodes in the cluster. Receipt of a Heartbeat implies that the DataNode is functioning properly. A Blockreport contains a list of all blocks on a DataNode.

    在这里插入图片描述

    6.本课程使用的Linux环境介绍

    • linux:
    mkdir software  #软件安装包
    mkdir app  # 软件安装目录
    mkdir data # 存放数据
    mkdir lib  # 存放作业
    mkdir shell # 存放脚本
    mkdir maven_resp # 存放maven依赖包
    
    切换rooter 用户:sudo -i
    切换hadoop用户:su hadoop
    
    查linux版本 uname -a
    

    7.Hadoop部署前置介绍

    使用Hadoop版本:CDH:Apache Hadoop 2.6.0-cdh5.15.1

    https://archive.cloudera.com/cdh5/cdh/5/

    学习使用单机版(Hadoop Hive Spark)

    java1.8

    8.JDK1.8部署详解

    source .bash_profile  # 激活
    
     java -version
    

    bash_profile

    # .bash_profile
    
    # Get the aliases and functions
    if [ -f ~/.bashrc ]; then
    	. ~/.bashrc
    fi
    
    # User specific environment and startup programs
    
    PATH=$PATH:$HOME/.local/bin:$HOME/bin
    
    
    export JAVA_HOME=/home/hadoop/app/jdk1.8.0_91
    export PATH=$JAVA_HOME/bin:$PATH
    
    export HADOOP_HOME=/home/hadoop/app/hadoop-2.6.0-cdh5.15.1
    export PATH=$HADOOP_HOME/bin:$PATH
    
    export HIVE_HOME=/home/hadoop/app/hive-1.1.0-cdh5.15.1
    export PATH=$HIVE_HOME/bin:$PATH
    
    export PATH
    
    

    9.ssh无密码登陆部署详解

    ll -a
    
    ll -la
    

    10.Hadoop安装目录详解及hadoop-env配置

    在这里插入图片描述

    11.HDFS格式化以及启动详解

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    12.HDFS常见文件之防火墙干扰

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    查看你防火墙 : sudo firewall-cmd --state
    关闭防火墙:sudo systemctl stop firewalld.service
    

    13.Hadoop停止集群以及如何单个进程启动

    停止
    在这里插入图片描述

    在这里插入图片描述

    14.Hadoop命令行操作详解

    在这里插入图片描述

    15.深度剖析Hadoop文件的存储机制

    在这里插入图片描述

    16.HDFS API编程之开发环境搭建

    17. HDFS API编程之第一个应用程序的开发

    18.HDFS API编程之jUnit封装

    19 HDFS API编程之查看HDFS文件内容

    20 HDFS API编程之创建文件并写入内容

    21 HDFS API编程之副本系数深度剖析

    22 HDFS API编程之重命名

    23 HDFS API编程之copyFromLocalFile

    24 HDFS API编程之带进度的上传大文件

    25 HDFS API编程之下载文件

    26 HDFS API编程之列出文件夹下的所有内容

    27 HDFS API编程之递归列出文件夹下的所有文件

    28 HDFS API编程之查看文件块信息

    29 HDFS API编程之删除文件

    30 HDFS项目实战之需求分析

    31 HDFS项目实战之代码框架编写

    package com.imooc.bigdata.hadoop.hdfs;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.*;
    
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.net.URI;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * 使用HDFS API完成wordcount统计
     *
     * 需求:统计HDFS上的文件的wc,然后将统计结果输出到HDFS
     *
     * 功能拆解:
     * 1)读取HDFS上的文件 ==> HDFS API
     * 2)业务处理(词频统计):对文件中的每一行数据都要进行业务处理(按照分隔符分割) ==> Mapper
     * 3)将处理结果缓存起来   ==> Context
     * 4)将结果输出到HDFS ==> HDFS API
     *
     */
    public class HDFSWCApp01 {
    
        public static void main(String[] args) throws Exception {
    
            // 1)读取HDFS上的文件 ==> HDFS API
            Path input = new Path("/hdfsapi/test/hello.txt");
    
    
            // 获取要操作的HDFS文件系统
            FileSystem fs = FileSystem.get(new URI("hdfs://192.168.199.233:8020"), new Configuration(),"hadoop");
    
            RemoteIterator<LocatedFileStatus> iterator = fs.listFiles(input, false);
    
            ImoocMapper mapper = new WordCountMapper();
            ImoocContext context = new ImoocContext();
    
            while(iterator.hasNext()) {
                LocatedFileStatus file = iterator.next();
                FSDataInputStream in = fs.open(file.getPath());
                BufferedReader reader = new BufferedReader(new InputStreamReader(in));
    
                String line = "";
                while ((line = reader.readLine()) != null) {
    
                    // 2)业务处理(词频统计)   (hello,3)
                    // TODO... 在业务逻辑完之后将结果写到Cache中去
                    mapper.map(line, context);
                }
    
                reader.close();
                in.close();
            }
    
    
            //TODO... 3 将处理结果缓存起来  Map
    
            Map<Object, Object> contextMap = context.getCacheMap();
    
            // 4)将结果输出到HDFS ==> HDFS API
            Path output = new Path("/hdfsapi/output/");
    
            FSDataOutputStream out = fs.create(new Path(output, new Path("wc.out")));
    
            // TODO... 将第三步缓存中的内容输出到out中去
            Set<Map.Entry<Object, Object>> entries = contextMap.entrySet();
            for(Map.Entry<Object, Object> entry : entries) {
                out.write((entry.getKey().toString() + " \t " + entry.getValue() + "\n").getBytes());
            }
    
            out.close();
            fs.close();
    
            System.out.println("PK哥的HDFS API统计词频运行成功....");
    
        }
    
    }
    
    

    32 HDFS项目实战之自定义上下文

    package com.imooc.bigdata.hadoop.hdfs;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 自定义上下文,其实就是缓存
     */
    public class ImoocContext {
    
        private Map<Object, Object> cacheMap = new HashMap<Object, Object>();
    
        public Map<Object, Object> getCacheMap() {
            return cacheMap;
        }
    
        /**
         * 写数据到缓存中去
         * @param key 单词
         * @param value 次数
         */
        public void write(Object key, Object value) {
            cacheMap.put(key, value);
        }
    
        /**
         * 从缓存中获取值
         * @param key 单词
         * @return  单词对应的词频
         */
        public Object get(Object key) {
            return cacheMap.get(key);
        }
    
    
    }
    
    

    33 HDFS项目实战之自定义处理类实现

    package com.imooc.bigdata.hadoop.hdfs;
    
    /**
     * 自定义Mapper
     */
    public interface ImoocMapper {
    
        /**
         *
         * @param line  读取到到每一行数据
         * @param context  上下文/缓存
         */
        public void map(String line, ImoocContext context);
    }
    
    
    package com.imooc.bigdata.hadoop.hdfs;
    
    /**
     * 自定义wc实现类
     */
    public class WordCountMapper implements ImoocMapper {
    
        public void map(String line, ImoocContext context) {
            String[] words = line.split("\t");
    
            for(String word : words) {
                Object value = context.get(word);
                if(value == null) { // 表示没有出现过该单词
                    context.write(word, 1);
                } else {
                    int v = Integer.parseInt(value.toString());
                    context.write(word, v+1);  // 取出单词对应的次数+1
                }
            }
    
        }
    }
    
    

    34 HDFS项目实战之功能实现

    package com.imooc.bigdata.hadoop.hdfs;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.*;
    
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.net.URI;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * 使用HDFS API完成wordcount统计
     *
     * 需求:统计HDFS上的文件的wc,然后将统计结果输出到HDFS
     *
     * 功能拆解:
     * 1)读取HDFS上的文件 ==> HDFS API
     * 2)业务处理(词频统计):对文件中的每一行数据都要进行业务处理(按照分隔符分割) ==> Mapper
     * 3)将处理结果缓存起来   ==> Context
     * 4)将结果输出到HDFS ==> HDFS API
     *
     */
    public class HDFSWCApp01 {
    
        public static void main(String[] args) throws Exception {
    
            // 1)读取HDFS上的文件 ==> HDFS API
            Path input = new Path("/hdfsapi/test/hello.txt");
    
    
            // 获取要操作的HDFS文件系统
            FileSystem fs = FileSystem.get(new URI("hdfs://192.168.199.233:8020"), new Configuration(),"hadoop");
    
            RemoteIterator<LocatedFileStatus> iterator = fs.listFiles(input, false);
    
            ImoocMapper mapper = new WordCountMapper();
            ImoocContext context = new ImoocContext();
    
            while(iterator.hasNext()) {
                LocatedFileStatus file = iterator.next();
                FSDataInputStream in = fs.open(file.getPath());
                BufferedReader reader = new BufferedReader(new InputStreamReader(in));
    
                String line = "";
                while ((line = reader.readLine()) != null) {
    
                    // 2)业务处理(词频统计)   (hello,3)
                    // TODO... 在业务逻辑完之后将结果写到Cache中去
                    mapper.map(line, context);
                }
    
                reader.close();
                in.close();
            }
    
    
            //TODO... 3 将处理结果缓存起来  Map
    
            Map<Object, Object> contextMap = context.getCacheMap();
    
            // 4)将结果输出到HDFS ==> HDFS API
            Path output = new Path("/hdfsapi/output/");
    
            FSDataOutputStream out = fs.create(new Path(output, new Path("wc.out")));
    
            // TODO... 将第三步缓存中的内容输出到out中去
            Set<Map.Entry<Object, Object>> entries = contextMap.entrySet();
            for(Map.Entry<Object, Object> entry : entries) {
                out.write((entry.getKey().toString() + " \t " + entry.getValue() + "\n").getBytes());
            }
    
            out.close();
            fs.close();
    
            System.out.println("PK哥的HDFS API统计词频运行成功....");
    
        }
    
    }
    
    

    在这里插入图片描述

    35 HDFS项目实战之使用自定义配置文件重构代码

    INPUT_PATH=/hdfsapi/test/h.txt
    OUTPUT_PATH=/hdfsapi/output/
    OUTPUT_FILE=wc.out5
    HDFS_URI=hdfs://192.168.199.233:8020
    MAPPER_CLASS=com.imooc.bigdata.hadoop.hdfs.CaseIgnoreWordCountMapper
    
    package com.imooc.bigdata.hadoop.hdfs;
    
    /**
     * 常量
     */
    public class Constants {
    
        public static final String INPUT_PATH = "INPUT_PATH";
    
        public static final String OUTPUT_PATH = "OUTPUT_PATH";
    
        public static final String OUTPUT_FILE = "OUTPUT_FILE";
    
        public static final String HDFS_URI = "HDFS_URI";
    
        public static final String MAPPER_CLASS = "MAPPER_CLASS";
    
    }
    
    
    package com.imooc.bigdata.hadoop.hdfs;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.*;
    
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.net.URI;
    import java.util.Map;
    import java.util.Properties;
    import java.util.Set;
    
    /**
     * 使用HDFS API完成wordcount统计
     *
     * 需求:统计HDFS上的文件的wc,然后将统计结果输出到HDFS
     *
     * 功能拆解:
     * 1)读取HDFS上的文件 ==> HDFS API
     * 2)业务处理(词频统计):对文件中的每一行数据都要进行业务处理(按照分隔符分割) ==> Mapper
     * 3)将处理结果缓存起来   ==> Context
     * 4)将结果输出到HDFS ==> HDFS API
     *
     */
    public class HDFSWCApp02 {
    
        public static void main(String[] args) throws Exception {
    
            // 1)读取HDFS上的文件 ==> HDFS API
    
    
            Properties properties = ParamsUtils.getProperties();
            Path input = new Path(properties.getProperty(Constants.INPUT_PATH));
    
    
            // 获取要操作的HDFS文件系统
            FileSystem fs = FileSystem.get(new URI(properties.getProperty(Constants.HDFS_URI)), new Configuration(),"hadoop");
    
            RemoteIterator<LocatedFileStatus> iterator = fs.listFiles(input, false);
    
            // TODO... 通过反射创建对象
            Class<?> clazz = Class.forName(properties.getProperty(Constants.MAPPER_CLASS));
            ImoocMapper mapper = (ImoocMapper)clazz.newInstance();
    
    
            //ImoocMapper mapper = new WordCountMapper();
            ImoocContext context = new ImoocContext();
    
            while(iterator.hasNext()) {
                LocatedFileStatus file = iterator.next();
                FSDataInputStream in = fs.open(file.getPath());
                BufferedReader reader = new BufferedReader(new InputStreamReader(in));
    
                String line = "";
                while ((line = reader.readLine()) != null) {
    
                    // 2)业务处理(词频统计)   (hello,3)
                    // TODO... 在业务逻辑完之后将结果写到Cache中去
                    mapper.map(line, context);
                }
    
                reader.close();
                in.close();
            }
    
    
            //TODO... 3 将处理结果缓存起来  Map
    
            Map<Object, Object> contextMap = context.getCacheMap();
    
            // 4)将结果输出到HDFS ==> HDFS API
            Path output = new Path(properties.getProperty(Constants.OUTPUT_PATH));
    
            FSDataOutputStream out = fs.create(new Path(output, new Path(properties.getProperty(Constants.OUTPUT_FILE))));
    
            // TODO... 将第三步缓存中的内容输出到out中去
            Set<Map.Entry<Object, Object>> entries = contextMap.entrySet();
            for(Map.Entry<Object, Object> entry : entries) {
                out.write((entry.getKey().toString() + " \t " + entry.getValue() + "\n").getBytes());
            }
    
            out.close();
            fs.close();
    
            System.out.println("PK哥的HDFS API统计词频运行成功....");
    
        }
    
    }
    
    

    36 HDFS项目实战之使用反射创建自定义Mapper对象

    MAPPER_CLASS=com.imooc.bigdata.hadoop.hdfs.CaseIgnoreWordCountMapper
    
        public static final String MAPPER_CLASS = "MAPPER_CLASS";
    
            // TODO... 通过反射创建对象
            Class<?> clazz = Class.forName(properties.getProperty(Constants.MAPPER_CLASS));
            ImoocMapper mapper = (ImoocMapper)clazz.newInstance();
    

    37 HDFS项目实战之可插拔的业务逻辑处理

    38 HDFS Replica Placement Policy

    39 HDFS写数据流程图解

    40 HDFS读数据流程图解

    41 HDFS Checkpoint详解

    42 HDFS SaveMode

    展开全文
  • 第3章-分布式文件系统HDFS.pdf
  • 第2讲_分布式文件系统HDFS.pdf
  • 分布式文件系统HDFS 接着前面的文章: (一)Ubuntu18.04,Hadoop3.1.3伪分布式环境搭建, (二)hadoop 分布式文件系统HDFS 这节是HDFS的实践。 实验环境: Ubuntu18.04 Hadoop3.1.3 文章目录分布式文件系统HDFS一...

    分布式文件系统HDFS

    接着前面的文章:
    (一)Ubuntu18.04,Hadoop3.1.3伪分布式环境搭建
    (二)hadoop 分布式文件系统HDFS


    这节是HDFS的实践。
    实验环境:
    Ubuntu18.04
    Hadoop3.1.3

    时间 
    2020-08

    在学习HDFS编程实践前,我们需要启动Hadoop。执行如下命令

    cd /usr/local/hadoop
    ./sbin/start-dfs.sh #启动hadoop
    

    一、利用Shell命令与HDFS进行交互

    Hadoop支持很多Shell命令,其中fs是HDFS最常用的命令,利用fs可以查看HDFS文件系统的目录结构、上传和下载数据、创建文件等。

    1. hadoop fs适用于任何不同的文件系统,比如本地文件系统和HDFS文件系统
    2. hadoop dfs只能适用于HDFS文件系统
    3. hdfs dfs跟hadoop dfs的命令作用一样,也只能适用于HDFS文件系统
      在这里插入图片描述

    在终端输入如下命令,可以查看具体某个命令的作用
    例如:我们查看put命令如何使用,可以输入如下命令

    ./bin/hadoop fs -help put
     
    

    在这里插入图片描述

    1.目录操作

    需要注意的是,Hadoop系统安装好以后,第一次使用HDFS时,需要首先在HDFS中创建用户目录。本教程全部采用hadoop用户登录Linux系统,因此,需要在HDFS中为hadoop用户创建一个用户目录,命令如下:

    cd /usr/local/hadoop
    ./bin/hdfs dfs –mkdir –p /user/hadoop
    

    该命令中表示在HDFS中创建一个“/user/hadoop”目录,“–mkdir”是创建目录的操作,“-p”表示如果是多级目录,则父目录和子目录一起创建,这里“/user/hadoop”就是一个多级目录,因此必须使用参数“-p”,否则会出错。
    如果要删除目录:

    hadoop fs -rm -r /user/hadoop
    

    在这里插入图片描述

    “/user/hadoop”目录就成为hadoop用户对应的用户目录,可以使用如下命令显示HDFS中与当前用户hadoop对应的用户目录下的内容:

     ./bin/hdfs dfs –ls .
    

    该命令中,“-ls”表示列出HDFS某个目录下的所有内容,“.”表示HDFS中的当前用户目录,也就是“/user/hadoop”目录,因此,上面的命令和下面的命令是等价的:

    ./bin/hdfs dfs –ls /user/hadoop
    

    如果要列出HDFS上的所有目录,可以使用如下命令:

    ./bin/hdfs dfs –ls
    

    下面,可以使用如下命令创建一个input目录:

     ./bin/hdfs dfs –mkdir input
    

    在创建个input目录时,采用了相对路径形式,实际上,这个input目录创建成功以后,它在HDFS中的完整路径是“/user/hadoop/input”。如果要在HDFS的根目录下创建一个名称为input的目录,则需要使用如下命令:

    ./bin/hdfs dfs –mkdir /input
    

    可以使用rm命令删除一个目录,比如,可以使用如下命令删除刚才在HDFS中创建的“/input”目录(不是“/user/hadoop/input”目录):

    ./bin/hdfs dfs –rm –r /input
    

    上面命令中,“-r”参数表示如果删除“/input”目录及其子目录下的所有内容,如果要删除的一个目录包含了子目录,则必须使用“-r”参数,否则会执行失败。

    2.文件操作

    在实际应用中,经常需要从本地文件系统向HDFS中上传文件,或者把HDFS中的文件下载到本地文件系统中。
    首先,使用vim编辑器,在本地Linux文件系统的“/home/hadoop/”目录下创建一个文件myLocalFile.txt,里面可以随意输入一些单词。
    然后,可以使用如下命令把本地文件系统的“/home/hadoop/myLocalFile.txt”上传到HDFS中的当前用户目录的input目录下,也就是上传到HDFS的“/user/hadoop/input/”目录下:

    ./bin/hdfs dfs -put /home/hadoop/myLocalFile.txt  input
    

    可以使用ls命令查看一下文件是否成功上传到HDFS中,具体如下:

    ./bin/hdfs dfs –ls input
    

    该命令执行后会显示类似如下的信息:

    下面使用如下命令查看HDFS中的myLocalFile.txt这个文件的内容:

    ./bin/hdfs dfs –cat input/myLocalFile.txt
    

    下面把HDFS中的myLocalFile.txt文件下载到本地文件系统中的“/home/hadoop/下载/”这个目录下,命令如下:

    ./bin/hdfs dfs -get input/myLocalFile.txt  /home/hadoop/下载
    

    可以使用如下命令,到本地文件系统查看下载下来的文件myLocalFile.txt:

    $ cd ~
    $ cd 下载
    $ ls
    $ cat myLocalFile.txt
    

    最后,了解一下如何把文件从HDFS中的一个目录拷贝到HDFS中的另外一个目录。比如,如果要把HDFS的“/user/hadoop/input/myLocalFile.txt”文件,拷贝到HDFS的另外一个目录“/input”中(注意,这个input目录位于HDFS根目录下),可以使用如下命令:

    ./bin/hdfs dfs -cp input/myLocalFile.txt /input
    

    二、利用Web界面管理HDFS

    打开Linux自带的Firefox浏览器,点这个链接HDFS的Web界面,即可看到HDFS的web管理界面,或者在window系统下的浏览器 www.虚拟机ip:9870
    在这里插入图片描述
    点击Utilities->Browse thr file system, 输入/ 点击go即可看到完整的根目录:
    在这里插入图片描述

    三、利用Java API与HDFS进行交互

    Hadoop不同的文件系统之间通过调用Java API进行交互,上面介绍的Shell命令,本质上就是Java API的应用。下面提供了Hadoop官方的Hadoop API文档,想要深入学习Hadoop,可以访问如下网站,查看各个API的功能。
    Hadoop API文档
    利用Java API进行交互,需要利用软件Eclipse编写Java程序。

    (一) 在Ubuntu中安装Eclipse

    Ubuntu(18.04)下安装eclipse

    (二)在Eclipse创建项目

    第一次打开Eclipse,需要填写workspace(工作空间),用来保存程序所在的位置,这里按照默认,不需要改动.
    由于当前是采用hadoop用户登录了Linux系统,因此,默认的工作空间目录位于hadoop用户目录“/home/hadoop”下
    选择“File->New->Java Project”菜单,开始创建一个Java工程
    在这里插入图片描述

    起名,选择next,先不要选finish。

    (三)为项目添加需要用到的JAR包

    进入下一步的设置以后,点击Libraries,会弹出如图所示界面。
    在这里插入图片描述

    需要在这个界面中加载该Java工程所需要用到的JAR包,这些JAR包中包含了可以访问HDFS的Java API。这些JAR包都位于Linux系统的Hadoop安装目录下,对于本教程(如果是按照之前的教程所配置)而言,就是在“/usr/local/hadoop/share/hadoop”目录下。点击界面中的“Libraries”选项卡,然后,点击界面右侧的“Add External JARs…”按钮,
    在这里插入图片描述

    在该界面中,上面的一排目录按钮(即“usr”、“local”、“hadoop”、“share”、“hadoop”、“mapreduce”和“lib”),当点击某个目录按钮时,就会在下面列出该目录的内容。
    为了编写一个能够与HDFS交互的Java应用程序,一般需要向Java工程中添加以下JAR包:
    (1)”/usr/local/hadoop/share/hadoop/common”目录下的hadoop-common-3.1.3.jar和haoop-nfs-3.1.3.jar;
    (2)/usr/local/hadoop/share/hadoop/common/lib”目录下的所有JAR包;
    (3)“/usr/local/hadoop/share/hadoop/hdfs”目录下的haoop-hdfs-3.1.3.jar和haoop-hdfs-nfs-3.1.3.jar和hadoop-hdfs-client-3.1.1.jar ;
    (4)“/usr/local/hadoop/share/hadoop/hdfs/lib”目录下的所有JAR包。
    比如,如果要把“/usr/local/hadoop/share/hadoop/common”目录下的hadoop-common-3.1.3.jar和haoop-nfs-3.1.3.jar添加到当前的Java工程中,可以在界面中点击目录按钮,进入到common目录,然后,界面会显示出common目录下的所有内容
    请在界面中用鼠标点击选中hadoop-common-3.1.3.jar和haoop-nfs-3.1.3.jar,然后点击界面“打开”按钮,就可以把这两个JAR包增加到当前Java工程中,出现的界面如图
    在这里插入图片描述

    从这个界面中可以看出,hadoop-common-3.1.3.jar和haoop-nfs-3.1.3.jar已经被添加到当前Java工程中。然后,按照类似的操作方法,可以再次点击“Add External JARs…”按钮,把剩余的其他JAR包都添加进来。需要注意的是,当需要选中某个目录下的所有JAR包时,可以使用“Ctrl+A”组合键进行全选操作。全部添加完毕以后,就可以点击界面右下角的“Finish”按钮,完成Java工程HDFSExample的创建。

    (四)编写Java应用程序代码

    下面编写一个Java应用程序,用来检测HDFS中是否存在一个文件。
    请在Eclipse工作界面左侧的“Package Explorer”面板中(如图所示),找到刚才创建好的工程名称“HDFSExample”,然后在该工程名称上点击鼠标右键,在弹出的菜单中选择“New->Class”菜单。
    在这里插入图片描述

    选择“New->Class”菜单以后会出现如图:
    在这里插入图片描述

    在该界面中,只需要在“Name”后面输入新建的Java类文件的名称,这里采用名称“HDFSFileIfExist”,其他都可以采用默认设置,然后,点击界面右下角“Finish”按钮:
    在这里插入图片描述

    修改代码为:

    import org.apache.hadoop.conf.Configuration;  
    import org.apache.hadoop.fs.FileSystem;  
    import org.apache.hadoop.fs.Path;  
    public class HDFSFileExist {  
        public static void main(String[] args){  
            try{  
                String fileName = "test";  
                Configuration conf = new Configuration();  
                conf.set("fs.defaultFS", "hdfs://localhost:9000");  
                conf.set("fs.hdfs.impl", "org.apache.hadoop.hdfs.DistributedFileSystem");  
                FileSystem fs = FileSystem.get(conf);  
                if(fs.exists(new Path(fileName))){  
                    System.out.println("文件存在");  
                }else{  
                    System.out.println("文件不存在");  
                }  
       
            }catch (Exception e){  
                e.printStackTrace();  
            }  
        }  
    }  
    

    (五)编译运行程序

    在开始编译运行程序之前,请一定确保Hadoop已经启动运行,如果还没有启动,需要打开一个Linux终端,输入以下命令启动Hadoop:

    cd /usr/local/hadoop
    ./sbin/start-dfs.sh
    

    Shell 命令
    现在就可以编译运行上面编写的代码。
    点击run运行,程序运行结束后,会在底部的“Console”面板中显示运行结果信息(如图所示)。由于目前HDFS的“/user/hadoop”目录下还没有test文件,因此,程序运行结果是“文件不存在”。同时,“Console”面板中还会显示一些类似“log4j:WARN…”的警告信息,可以不用理会。
    在这里插入图片描述

    (六)应用程序的部署

    下面介绍如何把Java应用程序生成JAR包,部署到Hadoop平台上运行。首先,在Hadoop安装目录下新建一个名称为myapp的目录,用来存放我们自己编写的Hadoop应用程序,可以在Linux的终端中执行如下命令:

    cd /usr/local/hadoop
    mkdir myapp
    

    然后,请在Eclipse工作界面左侧的“Package Explorer”面板中,在工程名称“HDFSExample”上点击鼠标右键,在弹出的菜单中选“Export”,如图
    在这里插入图片描述

    在该界面中,选择“Runnable JAR file”,然后,点击“Next>”按钮,弹出如图
    在这里插入图片描述

    在该界面中,“Launch configuration”用于设置生成的JAR包被部署启动时运行的主类,需要在下拉列表中选择刚才配置的类“HDFSFileIfExist-HDFSExample”。在“Export destination”中需要设置JAR包要输出保存到哪个目录,比如,这里设置为“/usr/local/hadoop/myapp/HDFSExample.jar”。在“Library handling”下面选择“Extract required libraries into generated JAR”。然后,点击“Finish”按钮,会出现警告信息,忽略就行。
    打包结束,也会出现一个如图的警告:
    在这里插入图片描述

    可以忽略该界面的信息,直接点击界面右下角的“OK”按钮。至此,已经顺利把HDFSExample工程打包生成了HDFSExample.jar。可以到Linux系统中查看一下生成的HDFSExample.jar文件,可以在Linux的终端中执行如下命令:

    cd /usr/local/hadoop/myapp
    ls
    

    在这里插入图片描述

    可以看到,“/usr/local/hadoop/myapp”目录下已经存在一个HDFSExample.jar文件。现在,就可以在Linux系统中,使用hadoop jar命令运行程序,命令如下:

    cd /usr/local/hadoop
    ./bin/hadoop jar ./myapp/HDFSExample.jar
    

    在这里插入图片描述

    或者也可以使用如下命令运行程序:

    cd /usr/local/hadoop
    java -jar ./myapp/HDFSExample.jar
    

    命令执行结束后,会在屏幕上显示执行结果“文件不存在”。
    至此,检测HDFS文件是否存在的程序,就顺利部署完成了。

    附录:自己练习用的代码文件

    下面给出几个代码文件,供读者自己练习。
    1.写入文件

    import org.apache.hadoop.conf.Configuration;  
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.fs.FSDataOutputStream;
    import org.apache.hadoop.fs.Path;
    
    public class Chapter3 {    
            public static void main(String[] args) { 
                    try {
                            Configuration conf = new Configuration();  
                            conf.set("fs.defaultFS","hdfs://localhost:9000");
                            conf.set("fs.hdfs.impl","org.apache.hadoop.hdfs.DistributedFileSystem");
                            FileSystem fs = FileSystem.get(conf);
                            byte[] buff = "Hello world".getBytes(); // 要写入的内容
                            String filename = "hello.txt"; //要写入的文件名
                            FSDataOutputStream os = fs.create(new Path(filename));
                            os.write(buff,0,buff.length);
                            System.out.println("Create:"+ filename);
                            os.close();
                            fs.close();
                    } catch (Exception e) {  
                            e.printStackTrace();  
                    }  
            }  
    }
     
    

    在这里插入图片描述

    2.读取文件

    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.fs.FSDataInputStream;
    
    public class Chapter3 {
            public static void main(String[] args) {
                    try {
                            Configuration conf = new Configuration();
                            conf.set("fs.defaultFS","hdfs://localhost:9000");
                            conf.set("fs.hdfs.impl","org.apache.hadoop.hdfs.DistributedFileSystem");
                            FileSystem fs = FileSystem.get(conf);
                            Path file = new Path("test"); 
                            FSDataInputStream getIt = fs.open(file);
                            BufferedReader d = new BufferedReader(new InputStreamReader(getIt));
                            String content = d.readLine(); //读取文件一行
                            System.out.println(content);
                            d.close(); //关闭文件
                            fs.close(); //关闭hdfs
                    } catch (Exception e) {
                            e.printStackTrace();
                    }
            }
    }
    
    展开全文
  • Hadoop 分布式文件系统 HDFS 文章目录Hadoop 分布式文件系统 HDFS1. 概述2. HDFS概念2.0 HDFS 架构图2.1 数据块(block)2.2 namenode 与 datanode2.2.1 NameNode2.2.2 DataNode2.2.3 HDFS Client2.2.4 HDFS故障处理...

    Hadoop 分布式文件系统 HDFS

    1. 概述

    当要存储的文件超过单台计算机所能存储的容量时,就需要通过分区,将文件拆分后保存到若干台计算机上,管理网络中跨多台计算机的文件系统成为分布式文件系统。

    Hadoop提供了一个称为HDFS的分布式文件系统(Hadoop Distributed Filesystem)。HDFS提供了高可靠性、高扩展性和高吞吐率的数据存储服务。

    HDFS优点

    1. 高容错性

      • 数据自动保存多个副本。它通过增加副本的形式,提高容错性。

      • 一个副本丢失以后,它可以自动恢复,这是由 HDFS 内部机制实现的,我们不必关心。

    2. 适合批处理

      • 它是通过移动计算而不是移动数据。

      • 它会把数据位置暴露给计算框架。

    3. 适合大数据处理

      • 处理数据达到 GB、TB、甚至PB级别的数据。
      • 能够处理百万规模以上的文件数量,数量相当之大。
      • 能够处理10K节点的规模。
    4. 流式文件访问

      • 一次写入,多次读取。文件一旦写入不能修改,只能追加。

      • 它能保证数据的一致性。

    5. 可构建在廉价机器上

      • 它通过多副本机制,提高可靠性。

      • 它提供了容错和恢复机制。比如某一个副本丢失,可以通过其它副本来恢复。

    HDFS缺点

    2. HDFS概念

    2.0 HDFS 架构图

    在这里插入图片描述

    2.1 数据块(block)

    每个磁盘都有默认的数据块大小,数据块(block)是磁盘用于读取数据的最小单位。

    1. HDFS中也有数据块(block)的概念,HDFS中默认数据块的大小为128M,当我们要保存一个文件到HDFS时,HDFS会将文件按照数据块的大小线性切割分散的保存到集群的节点中。

    2. 文件上传可以设置保存的数据块大小,同一个文件数据块的大小一样,不同文件的数据块大小可以不同。

    3. HDFS可以设置数据块的副本数,数据块的副本分散存储在不同的集群节点中。

      默认副本放置规则:
      	- 副本1:放置在与客户端相同的节点上。
      	- 副本2:不同机架的节点上
      	- 副本3:与副本2相同机架的不同节点上
      	- 其他副本:随机挑选
      

    在这里插入图片描述

    1. HDFS支持一次写入多次读取,同一时刻只能有一个写入者。

    2. HDFS是定制的文件系统,支持写入数据,追加数据(append),文件一旦写入不支持修改。

    2.2 namenode 与 datanode

    HDFS集群中有两类节点以管理节点-工作节点模式运行,即一个namenode(管理节点)和多个datanode(工作节点)。

    2.2.1 NameNode

    NameNode管理文件系统的命名空间。

    NameNode维护着文件系统树以及整棵树所有的文件和目录,这些信息以两个文件形式永久保存在本地磁盘上:命名空间文件镜像文件和编辑日志文件。

    NameNode记录着每个文件中各个块的元数据(包括文件大小,创建时间,文件名…),但是NameNode并不保存数据块的位置信息,NameNode中关于数据块位置信息通过与DataNode的心跳实时获取更新。

    2.2.2 DataNode

    DataNode是文件系统的工作节点,用于保存文件块(block)数据。

    DataNode会根据需要存储并检索数据块(受客户端和NameNode调度),通过心跳定期向NameNode汇报数据块列表。

    2.2.3 HDFS Client

    Client用于通过与NN与DNN的交互来访问整个文件系统。Client通过HDFS提供的文件系统接口可以不用知道NN和DNN就可以进行数据交互。

    2.2.4 HDFS故障处理

    HDFS中存在单点故障和内存受限问题。

    NameNode备份

    在HDFS中如果NN出现故障,则整个HDFS就会陷入瘫痪。因为NN中存储着整个HDFS中所有数据块的元数据,如果NN故障我们就不知道应该怎样通过DNN内的数据块重建文件。

    备份机制:

    1. 备份元数据,通过配置NameNode在多个文件系统上保存元数据的持久状态。一般是在元数据写入磁盘的同时,写入一个远程挂载的网络文件系统(NFS)。
    2. 增加一个辅助NameNode(又称为:SecondaryNameNode(SNN)),这个辅助NameNode主要用于合并编辑日志(edits)与命名空间镜像(fsimage),可以防止编辑日志过大,导致NameNode重启缓慢。

    SNN执行合并时机:

    • 根据配置文件设置的时间间隔fs.checkpoint.period 默认3600秒

    • 根据配置文件设置edits log大小 fs.checkpoint.size 规定edits文件的最大值默认是64MB

    1551806245804

    DataNode备份。

    DN通过向NN发送心跳保持与其联系(3秒一次),如果NN10分钟没有收到DN的心跳,则认为其已经挂掉,并拷贝其上的数据块(block)到其它DN。

    2.2.5 HDFS 安全模式

    • namenode启动的时候,首先将映像文件(fsimage)载入内存,并执行编辑日志(edits)中的各项操作。
    • 一旦在内存中成功建立文件系统元数据的映射,则创建一个新的fsimage文件(这个操作不需要SecondaryNameNode)和一个空的编辑日志。
    • 此刻namenode运行在安全模式。即namenode的文件系统对于客服端来说是只读的。(显示目录,显示文件内容等。写、删除、重命名都会失败)。
    • 在此阶段Namenode收集各个datanode的报告,当数据块达到最小副本数以上时,会被认为是“安全”的, 在一定比例(可设置)的数据块被确定为“安全”后,再过若干时间,安全模式结束。
    • 当检测到副本数不足的数据块时,该块会被复制直到达到最小副本数,系统中数据块的位置并不是由namenode维护的,而是以块列表形式存储在datanode中。

    什么是元数据?

    任何文件系统中的数据分为数据和元数据。数据是指普通文件中的实际数据,而元数据指用来描述一个文件的特征的系统数据,诸如访问权限、文件拥有者以及文件数据块的分布信息(inode…)等等。在集群文件系统中,分布信息包括文件在磁盘上的位置以及磁盘在集群中的位置。用户需要操作一个文件必须首先得到它的元数据,才能定位到文件的位置并且得到文件的内容或相关属性。

    2.3 联邦HDFS(HDFS Federation)

    在这里插入图片描述

    NN在内存中保存有目录树以及元数据信息。对于拥有大量文件的超大集群来说,内存将会成为限制系统横向扩展的瓶颈。在Hadoop 2.x版本中通过引入联邦HDFS对NN进行扩展,其中每个NN管理命名空间的一部分,保存着其中一部分文件信息。所有NN共享所有DataNode存储资源。
    在这里插入图片描述

    2.4 HDFS HA

    在这里插入图片描述

    在HDFS HA中配置了主备NN(Active-Standby),当活动的NN失效,备用的NN就会接管处理客户端的请求,不会产生任何明显的中断。

    在HA中:主备NN之间需要通过高可用共享存储(NFS过滤器或群体日志管理器QJM)实现编辑日志的共享,当备用NN接管后,它将通过编辑日志实现与活动NN的同步。DataNode需要同时向主备NN发送数据块列表信息。

    QJM用于提供高可用的编辑日志(edits),它以一组日志节点journal节点(JN)的形式运行。

    在HDFS系统中有一个称为故障转移的控制器(Failover Controller)的组件,其管理着NN主备切换。NN故障切换有两种方式:手动切换,自动切换

    • 手动切换:通过命令实现主备之间的切换,可以用HDFS升级等场合

    • 自动切换:基于Zookeeper实现(NN中运行着的一个轻量级故障转移控制器,通过与Zookeeper的心跳判断NN是否故障,并进行故障切换)。

    在这里插入图片描述

    FailoverController主要包括三个组件:

    1. HealthMonitor: 监控NameNode是否处于unavailable或unhealthy状态。当前通过RPC调用NN相应的方法完成。
    2. ActiveStandbyElector: 管理和监控自己在ZK中的状态。
    3. ZKFailoverController 它订阅HealthMonitor 和ActiveStandbyElector 的事件,并管理NN的状态。

    基于Zookeeper自动切换方案

    1. ZooKeeper Failover Controller:通过心跳监控NameNode健康状态,

    2. 向Zookeeper注册NameNode

    3. NameNode挂掉后,ZKFC为NameNode竞争锁,获得ZKFC 锁的NameNode变为active

    3. HDFS 写入数据

    在这里插入图片描述

    具体步骤:

    1. 通过DistributedFileSystem对象调用create()来创建文件。
    2. DistributedFileSystem对NN创建一个RPC调用,在文件命名空间创建一个文件,HN会执行检查确保命名空间中没有相应数据块。
    3. 通过返回的FSDataOutputStream对象写入数据,在写入数据时通过FSDataOutputStream封装的DFSoutPutStream将数据块分割成更小的数据包,将其写入数据队列(Pipeline)中。
    4. DataStreamer会将写入数据队列的数据包以流式传输的方式传输到第一个节点,第一个节点传输完毕后会将数据包向后拷贝到第二个节点,然后第二个节点拷贝到第三个节点。
    5. 当数据包传输完毕后通过DFSOutputStream维护的内部数据包队列(ack package)来确认是否传输成功,只有收到管道中所有DN的确认信息后该数据包才会从确认队列中删除。
    6. 客户端完成数据的写入后,调用close方法关闭连接。
    7. 通告NN,等待NN确认文件写入。

    4. HDFS 读取数据

    在这里插入图片描述

    具体步骤:

    1. 客户端通过调用FileSyste的open()方法来打开希望读取的文件,该对象是DistributedFileSystem的实例。
    2. DistributedFileSystem通过远程调用(RPC)调用NN,确定文件起始块位置。对于每个块NN返回存有该块副本的DN地址,这些返回的DN会根据与客户端的距离进行排序。
    3. 通过DistributedFileSystem返回的FSDataInputStream封装的DFSInputStream对象的read()方法读取数据。
    4. 通过反复调用read()方法可以将数据从DN传输到客户端。
    5. 读取到达块的末端时,DFSInputStream关闭与DN的连接,然后寻找下一个最佳的DN,继续read()读取数据。
    6. 调用close方法关闭流。

    3. HDFS常用命令

    1. 列出HDFS下的文件
    hadoop dfs -ls
    
    1. 列出path目录下的文件
    hadoop dfs -ls path
    
    1. 上传data.txt文件到/path目录下
    hadoop dfs -put /data.txt /path
    
    1. 下载HDFS 内/data.txt文件到本地/path目录
    hadoop dfs -get /data.txt /path
    
    1. 删除HDFS内 /data.txt 文件
    hadoop dfs -rmr /data.txt
    
    1. 查看/data/TianQi.txt文件内容
    hadoop dfs -cat /data/TianQi.txt
    
    1. 建立目录
    hadoop dfs -mkdir /path
    

    4. HDFS Java接口

    Demo结构:

    在这里插入图片描述

    测试代码:

    public class Demo {
    	
    	private Configuration conf = null;
    	private FileSystem fs = null;
    	
    	@Before
    	public void conn() throws Exception {
    		conf = new Configuration(true);
    		fs = FileSystem.get(conf);
    	}
    	
    	@After
    	public void close() throws Exception {
    		fs.close();
    	}
    	
    	/**
    	 * 创建目录
    	 */
    	@Test
    	public void mkdirTest() throws Exception {
    		Path path = new Path("/data");
    		if(fs.exists(path)) {
    			fs.delete(path, true);
    		}else {			
    			fs.mkdirs(path);
    		}
    	}
    	
    	/**
    	 * 上传文件
    	 */
    	@Test
    	public void uploadTest() throws Exception {
    		InputStream inputStream = new FileInputStream(new File("C:\\Users\\LGX\\Desktop\\TianQi.txt"));
    		Path f = new Path("/data/TianQi.txt");
    		FSDataOutputStream dataOutputStream = fs.create(f);
    		IOUtils.copyBytes(inputStream, dataOutputStream, conf, true);
    		System.out.println("upload OK...");
    	}
    	
    	/**
    	 * 读取文件
    	 */
    	@Test
    	public void readTest() throws Exception {
    		InputStream is = fs.open(new Path("/data/TianQi.txt"));
    		IOUtils.copyBytes(is, System.out, conf);
    		System.out.println("ok...");
    	}
    	
    	/**
    	 * 获取文件状态信息
    	 */
    	@Test
    	public void statusTest() throws Exception {
    		FileStatus status = fs.getFileStatus(new Path("/data/TianQi.txt"));
    		
    		Path path = status.getPath();
    		System.out.println(path);
    		
    		String group = status.getGroup();
    		System.out.println(group);
    		
    		long len = status.getLen();
    		System.out.println(len);
    	}
    	
    	/**
    	 * 列出文件
    	 */
    	@Test
    	public void listStatusTest() throws Exception {
    		//获取目录下所有文件状态
    		FileStatus[] listStatus = fs.listStatus(new Path("/data"));
    		for (FileStatus fileStatus : listStatus) {
    			Path path = fileStatus.getPath();
    			System.out.println(path);
    		}
    	}
    }
    

    参考文献
    Hadoop权威指南4

    展开全文
  • Hadoop分布式文件系统HDFS的实战,需要的Hdfs.java文件 public static void main(String[] args) throws Exception { //上传文件到hadoop uploadFile(); createFile(); createDir(); fileRename(); deleteFile...
  • 第5章 分布式文件系统HDFSHDFS基本知识SHELL命令HDFS交互操作JAVA编程与HDFS实现交互目录页 5.1 HDFS基本知识5.1.1 分布式文件系统DFS简介5.1.2 Hadoop分布式文件系统(HDFS)5.1.3 HDFS存储数据5.2 SHELL命令HDFS交互...
  • 为了解决海量数据存储问题,Google开发了分布式文件系统GFSo HDFS是GFS的开源实现, 它是Hadoop的核心组件之一。HDFS提供了在通用硬件集群中进行分布式文件存储的能力,是一 个高容错性和高吞吐量的海量数据存储解决...

    5dd65f680c972b082092b1cbace65902.png

    为了解决海量数据存储问题,Google开发了分布式文件系统GFSo HDFS是GFS的开源实现, 它是Hadoop的核心组件之一。HDFS提供了在通用硬件集群中进行分布式文件存储的能力,是一 个高容错性和高吞吐量的海量数据存储解决方案。

    HDFS 简介

    HDFS (Hadoop Distributed Filesystem, Hadoop分布式文件系统)以流式数据访问模式来存储 超大文件,运行在由廉价普通机器组成的集群上,是管理网络中跨多台计算机存储的文件系统。它 的基本原理是将文件切分成同等大小的数据块,存储到多台机器上,将数据切分、容错、负载均衡 等功能透明化。

    HDFS上的文件被划分为相同大小的多个block块,以块作为独立的存储单位(称为数据块)为什么要弄成块来存储?第一,大文件用一个节点是存不下来的,势必分成块;第二,网络传输时 万一宕掉,可以小部分重传;第三,简化了存储管理,同时元数据就不需要和块一同存储了,用一 个单独的系统就可以管理这些块的元数据。所以block块是HDFS中最基本的存储单位。一个文件 Hadoop 2.x版本的HDFS块默认大小是128MB (Hadoop 1.X版本默认块大小是64MB)。默认块 大小是可以修改的,可以通过dfs.block.size设置。

    除了将文件分块,每个块文件也有副本,这是为了容错性。当一个机器挂了,想要恢复里面 的文件,就可以去其他机器找文件的副本。默认是三个副本,也可通过hdfs-site.xml中的replication 属性修改副本数量。

    HDFS的副本放置策略是将第一个副本放在本地节点,将第二个副本放到本地机架上的另外一 个节点,而将第三个副本放到不同机架上的节点。这种方式减少了机架间的写流量,从而提高了写 的性能。机架故障的概率远小于节点故障。将第三个副本放置在不同的机架上,这也防止了机架故障时数据的丢失。

    总之,HDFS在设计之初就是针对超大文件存储的,小文件不会提高访问和存储速度,反而会 降低。其次它釆用了流式数据访问,特点是一次写入多次读取。再有就是它运行在普通的标准硬件 (如PC服务器)之上,即使硬件故障,也可以通过副本冗余容错机制来保证数据的高可用。

    HDFS架构概述

    HDFS 釆用主从(Master/Slave)架构模型,分为 NameNode (名称节点)、SecondaryNameNode (第二名称节点)、DataNode (数据节点)这几个角色

    79e6ce037bb9b28dbb77d9d180c05c67.png

    —个典型的HDFS集群是由一个NameNode个SecondaryNameNode和若干个DataNode(通 常大于3个)组成的,通常是一个节点一个机器,它来管理对应节点的存储。

    (1) NameNode:主要负责文件系统命名空间的管理、存储文件目录的Metadata元数据信息, 主要包括文件目录、block块和文件对应关系,以及block块和DataNode数据节点的对耳关系。

    (2) SecondaryNameNode:是NameNode的冷备份,用来减少NameNode的工作量。

    (3) DataNode:负责存储客户端(Client)发来的Block数据块,执行数据块的读写操作。

    HDFS命名空间管理

    HDFS的命名空间包含目录、文件和块。在HDFS1.0架构中,在整个HDFS集群中只有一个 命名空间,并且只有唯一一个NameNode,负责对这个命名空间进行管理。HDFS使用的是传统的分级文件体系,因此用户可以像使用普通文件系统一样创建、删除目录和文件以及在目录间移动文 件、重命名文件等。HDFS2.0新特性federation联邦功能支持多个命名空间,并且允许在HDFS中 同时存在多个NameNode

    NameNode

    HDFS集群的命名空间是由NameNode来存储的。NameNode使用Fslmage和EditLog两个核 心的数据结构,如图所示。EditLog事务日志文件记录每一个对文件系统元数据的改变,如在 HDFS中创建一个新的文件,名称节点将会在EditLog中插入一条记录来记录这个改变。整个命名 空间的信息包括文件块的映射表等都存放在Fslmage文件中。

    05de6251e75e9f35d578dd2a96e3bea1.png

    名称节点启动时,它将从磁盘中读取Fslmage和EditLog,将EditLog中的所有事务应用到 Fslmage,然后将新的Fslmage刷新到本地磁盘中,因为事务已经被处理并已经持久化到Fslmage 中,然后就可以截去旧的EditLog。这个过程叫作检査点。

    Fslmage和Editlog是HDFS的重要数据结构,如果这些文件损坏,就会导致整个集群的失效。 因此可以配置成复制多个Fslmage和EditLog的副本,一般会在本地磁盘和网络文件系统NFS中 分别存放。

    SecondaryNameNode

    SecondaryNameNode是HDFS架构中的一个组成部分,它用来保存名称节点中对HDFS元数 据信息的备份,减小Editlog文件大小,从而缩短名称节点重启的时间。它一般是单独运行在一台 机器上。

    (1) SecondaryNameNode会定期和NameNode通信,请求其停止使用EditLog文件,暂时将 新的写操作写到一个新的文件edit.new中,这个操作是瞬间完成的,上层写日志的函数完全感觉不到差别。

    (2) SecondaryNameNode 通过 HTTP GET 方式从 NameNode 上获取到 Fslmage 和 EditLog 文 件,并下载到本地的相应目录下。

    (3) SecondaryNameNode将下载下来的Fslmage载入到内存,然后一条一条地执行EditLog 文件中的各项更新操作,使内存中的Fslmage保持最新。这个过程就是EditLog和Fslmage文件合 并。

    (4) SecondaryNameNode执行完(3)操作之后,会通过post方式将新的Fslmage文件发送 到NameNode节点上。

    (5) NameNode将从SecondaryNameNode接收到的新的Fslmage替换旧的Fslmage文件,同 时将Edit.new替换EditLog文件,从而减小EditLog文件大小。

    b29c88f74d4b740c9ed7e66e7ab5ca54.png

    第二名称节点相当于为名称节点设置一个“检査点”,周期性备份 名称节点中的元数据信息,但第二名称节点在HDFS设计中只是一个冷备份,并不能起到“热备 份”的作用。HDFS设计并不支持当名称节点故障时直接切换到第二名称节点。

    展开全文
  • Hadoop的能提供高吞吐量的数据访问,是集群式服务器的上的数据操作利器,这里就来为大家分享Java访问Hadoop分布式文件系统HDFS的配置说明:
  • 第三章-分布式文件系统HDFS 文章目录第三章-分布式文件系统HDFSHDFS简介HDFS相关概念HDFS块与组件名称节点第二名称节点数据节点HDFS体系结构HDFS存储原理冗余数据保存数据存取策略数据错误与恢复HDFS数据读写过程读...
  • Hadoop分布式文件系统hdfs代码分析 目录介绍 Datanode-数据块基本结构 主要介绍了HDFS中第二关系块结构,数据块到数据中断的映射关系。 退役-中断退款 主要介绍了数据异步下线取消机制。 INode-文件目录结构 主要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,048
精华内容 4,819
关键字:

分布式文件系统hdfs