Hadoop技术之HDFS

最新推荐文章于 2024-05-11 20:46:48 发布

编程小吉

最新推荐文章于 2024-05-11 20:46:48 发布

阅读量1.4k

点赞数 5

分类专栏：大数据文章标签：大数据 hdfs

本文链接：https://blog.csdn.net/qq_45747519/article/details/115794340

版权

大数据专栏收录该内容

7 篇文章 2 订阅

订阅专栏

HDFS基础

1.HDFS的相关概述

分布式文件系统把文件分布存储到多个计算机节点上，成千上万的计算机节点构成计算机集群。
分布式文件系统在物理结构上是由计算机集群中的多个节点构成的，这些节点分为两类：
- “主节点”(Master Node)或者也被称为“名称结点”(NameNode)
- “从节点”(Slave Node)或者也被称为“数据节点”(DataNode)

在这里插入图片描述

HDFS的优势
- 兼容廉价的硬件设备
- 流数据读写
- 大数据集
- 简单的文件模型
- 强大的跨平台兼容性
HDFS的局限性
- 不适合低延迟数据访问
- 无法高效存储大量小文件
- 不支持多用户写入及任意修改文件

2.HDFS的相关概念

存储块

HDFS默认一个块64MB，一个文件被分成多个块，以块作为存储单位块的大小远远大于普通文件系统，可以最小化寻址开销。
- 支持大规模文件存储
- 简化系统设计
- 适合数据备份
名称节点

在HDFS中，名称节点（NameNode）负责管理分布式文件系统的命名空间（Namespace），保存了两个核心的数据结构，即FsImage和EditLog
- FsImage 用于维护文件系统树以及文件树中所有的文件和文件夹的元数据
- EditLog 中记录了所有针对文件的创建、删除、重命名等操作
- 名称节点记录了每个文件中各个块所在的数据节点的位置信息
- 在名称节点启动的时候，它会将FsImage文件中的内容加载到内存中，之后再执行EditLog文件中的各项操作，使得内存中的元数据和实际的同步，存在内存中的元数据支持客户端的读操作。
第二名称节点

第二名称节点是HDFS架构中的一个组成部分，它是用来保存名称节点中对HDFS 元数据信息的备份，并减少名称节点重启的时间。SecondaryNameNode一般是单独运行在一台机器上
- 在名称节点运行期间，HDFS的所有更新操作都是直接写到EditLog中，久而久之， EditLog文件将会变得很大，所以这时可以使用SecondaryNameNode进行解决。
- 工作流程
  1. SecondaryNameNode会定期和NameNode通信，请求其停止使用EditLog文件，暂时将新的写操作写到一个新的文件edit.new上来，这个操作是瞬间完成，上层写日志的函数完全感觉不到差别。
  2. SecondaryNameNode通过HTTP GET方式从NameNode上获取到FsImage和EditLog文件，并下载到本地的相应目录下。
  3. SecondaryNameNode将下载下来的FsImage载入到内存，然后一条一条地执行EditLog文件中的各项更新操作，使得内存中的FsImage保持最新；这个过程就是EditLog和FsImage文件合并.
  4. SecondaryNameNode执行完（3）操作之后，会通过post方式将新的FsImage文件发送到NameNode节点上.
  5. NameNode将从SecondaryNameNode接收到的新的FsImage替换旧的FsImage文件，同时将edit.new替换EditLog文件，通过这个过程EditLog就变小了。
数据节点
- 数据节点是分布式文件系统HDFS的工作节点，负责数据的存储和读取，会根据客户端或者是名称节点的调度来进行数据的存储和检索，并且向名称节点定期发送自己所存储的块的列表
- 每个数据节点中的数据会被保存在各自节点的本地Linux文件系统中

3.HDFS的体系结构

概述
- HDFS采用了主从（Master/Slave）结构模型，一个HDFS集群包括一个名称节点（NameNode）和若干个数据节点（DataNode）。
- 名称节点作为中心服务器，负责管理文件系统的命名空间及客户端对文件的访问。
- 集群中的数据节点一般是一个节点运行一个数据节点进程，负责处理文件系统客户端的读/写请求，在名称节点的统一调度下进行数据块的创建、删除和复制等操作。每个数据节点的数据实际上是保存在本地Linux文件系统中的。
命名空间
- HDFS的命名空间包含目录、文件和块
- HDFS使用的是传统的分级文件体系，因此，用户可以像使用普通文件系统一样，创建、删除目录和文件，在目录间转移文件，重命名文件等
通信协议
- 所有的HDFS通信协议都是构建在TCP/IP协议基础之上的
- 客户端通过一个可配置的端口向名称节点主动发起TCP连接，并使用客户端协议与名称节点进行交互
- 名称节点和数据节点之间则使用数据节点协议进行交互
- 客户端与数据节点的交互是通过RPC（Remote Procedure Call）来实现的。在设计上，名称节点不会主动发起RPC，而是响应来自客户端和数据节点的RPC请求
客户端
- HDFS 客户端是一个库，暴露了HDFS文件系统接口，这些接口隐藏了HDFS实现中的大部分复杂性
- HDFS 客户端可以支持打开、读取、写入等常见的操作，并且提供了类似Shell的命令行方式来访问HDFS中的数据
- HDFS 也提供了Java API，作为应用程序访问文件系统的客户端编程接口
局限性
- 命名空间的限制：名称节点是保存在内存中的，因此，名称节点能够容纳的对象（文件、块）的个数会受到内存空间大小的限制。
- 性能的瓶颈：整个分布式文件系统的吞吐量，受限于单个名称节点的吞吐量。
- 隔离问题：由于集群中只有一个名称节点，只有一个命名空间，因此，无法对不同应用程序进行隔离。
- 集群的可用性：一旦这个唯一的名称节点发生故障，会导致整个集群变得不可用。

4.HDFS的存储原理

冗余数据保存

作为一个分布式文件系统，为了保证系统的容错性和可用性，HDFS采用了多副本方式对数据进行冗余存储，通常一个数据块的多个副本会被分布到不同的数据节点上。
- 加快了数据传输速度
- 容易检查数据错误
- 保证了数据可靠性
数据存取策略
- 存放
  - 第一个副本：放置在上传文件的数据节点；如果是集群外提交，则随机挑选一台磁盘不太满、CPU不太忙的节点
  - 第二个副本：放置在与第一个副本不同的机架的节点上
  - 第三个副本：与第一个副本相同机架的其他节点上
- 读取
  
  当客户端读取数据时，从名称节点获得数据块不同副本的存放位置列表，列表中包含了副本所在的数据节点，可以调用API来确定客户端和这些数据节点所属的机架ID，当发现某个数据块副本对应的机架ID和客户端对应的机架ID相同时，就优先选择该副本读取数据，如果没有发现，就随机选择一个副本读取数据
数据错误恢复

HDFS具有较高的容错性，可以兼容廉价的硬件，它把硬件出错看作一种常态，而不是异常，并设计了相应的机制检测数据错误和进行自动恢复。
- 名称节点出错
  
  名称节点保存了所有的元数据信息，其中，最核心的两大数据结构是FsImage和Editlog，如果这两个文件发生损坏，那么整个HDFS实例将失效。因此，HDFS设置了备份机制，把这些核心文件同步复制到备份服务器SecondaryNameNode上。当名称节点出错时，就可以根据备份服务器SecondaryNameNode中的FsImage和Editlog数据进行恢复。
- 数据节点出错
  
  由于一些数据节点的不可用，会导致一些数据块的副本数量小于冗余因子，名称节点会定期检查这种情况，一旦发现某个数据块的副本数量小于冗余因子，就会启动数据冗余复制，为它生成新的副本。
- 数据出错
  
  当客户端读取文件的时候，会先读取该信息文件，然后，利用该信息文件对每个读取的数据块进行校验，如果校验出错，客户端就会请求到另外一个数据节点读取该文件块，并且向名称节点报告这个文件块有错误，名称节点会定期检查并且重新复制这个块。

5.HDFS的数据读写

读数据

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();
                }
        }
}

在这里插入图片描述

写数据

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 = "test"; //要写入的文件名
                        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();  
                }  
        }  
}

在这里插入图片描述

6.HDFS 常用的Shell命令操作

安装好 hadoop 环境并启动 hdfs 服务之后，可以执行 hdfs shell 命令进行对 hdfs 的空间进行操作。

查看所有基础命令
```
hdfs dfs -help
```
查看所有管理命令
```
hadoop dfsadmin -help
```
查看文件内容
```
hdfs dfs -cat /文件路径
```
查看目录列表
```
hdfs dfs -ls /目录
```
创建目录
```
hdfs dfs -mkdir -p /目录
```
创建文件
```
hdfs dfs -touchz /文件路径
```

下载文件

hdfs dfs -get /文件路径 /本地保存路径

移动文件

hdfs dfs -mv /文件路径 /新的路径

删除文件
```
hdfs dfs -rmr /文件路径
```

上传文件

hdfs dfs -put /本地文件路径 /hdfs保存路径

内容追加

hdfs dfs -appendToFile /新的文件路径  /需要添加内容的文件路径

修改文件所属组
```
hdfs dfs -chgrp -R root /文件路径
```
修改文件的权限
```
hdfs dfs -chmod -R 777 /文件路径
```

7.HDFS 常用的Java API操作

设置好 hadoop 以及 hdfs 环境所需要的Jar包依赖之后，可以通过代码的方式对 hdfs 的空间进行操作。

创建目录

public class HdfsTest {
    private FileSystem fs = null;
    
    /**
     * 连接HDFS
     */
    @Before
    public void init() throws Exception {
        fs = FileSystem.get(new URI("hdfs://IP地址:9000"),new Configuration(),"root");
    }
    
    /**
     * 创建目录
     */
    @Test
    public void testMkdir() throws Exception {
        boolean flag = fs.mkdirs(new Path("/目录"));
        System.out.println(flag ? "创建成功" : "创建失败");
    }
    
    /**
     * 关闭HDFS
     */
    @After
    public void close()throws  Exception{
       fs.close();
    }
}

显示目录列表

public class HdfsTest {
    private FileSystem fs = null;
    private  List<String> hdfsPathsLists;
    
    /**
     * 连接HDFS
     */
    @Before
    public void init() throws Exception {
        fs = FileSystem.get(new URI("hdfs://IP地址:9000"),new Configuration(),"root");
    }
    
    /**
     * 显示目录列表
     */
    @Test
    public void getDirList() throws  Exception{
        hdfsPathsLists = new  ArrayList<>();
        getHdfsPaths(new Path("/目录"));
        
        for(String p : hdfsPathsLists){
            System.out.println(p);
        }
    }
    /**
     * 采用递归获取目录及目录下文件
     */
    private void  getHdfsPaths(Path path) throws Exception{
        FileStatus[]  dirs = fs.listStatus(path);
        for (FileStatus s :  dirs){
            hdfsPathsLists.add(s.getPath().toString());
            if(s.isDirectory()){
                getHdfsPaths(s.getPath());
            }
        }
    }
    
    /**
     * 关闭HDFS
     */
    @After
    public void close()throws  Exception{
       fs.close();
    }
}

删除目录

public class HdfsTest {
    private FileSystem fs = null;
    
    /**
     * 连接HDFS
     */
    @Before
    public void init() throws Exception {
        fs = FileSystem.get(new URI("hdfs://IP地址:9000"),new Configuration(),"root");
    }
    
    /**
     * 删除目录
     */
    @Test
    public void testRMdir() throws  Exception  {
        boolean flag = fs.deleteOnExit(new Path("/目录"));
        System.out.println(flag ? "删除成功" : "删除失败");
    }
    
    /**
     * 关闭HDFS
     */
    @After
    public void close()throws  Exception{
       fs.close();
    }
}

判断文件是否存在

public class HdfsTest {
    private FileSystem fs = null;
    
    /**
     * 连接HDFS
     */
    @Before
    public void init() throws Exception {
        fs = FileSystem.get(new URI("hdfs://IP地址:9000"),new Configuration(),"root");
    }
    
    /**
     * 判断文件是否存在
     */
    @Test
    public void testexistsFile()  throws Exception{
       String src = "hdfs://IP地址:9000/文件路径";
       boolean flag = fs.exists(new Path(src));
       if(flag){
            System.out.println("文件存在");
       }else {
            System.out.println("文件不存在");
        }
    }
    
    /**
     * 关闭HDFS
     */
    @After
    public void close()throws  Exception{
       fs.close();
    }
}

判断是否是文件或目录

public class HdfsTest {
    private FileSystem fs = null;
    
    /**
     * 连接HDFS
     */
    @Before
    public void init() throws Exception {
        fs = FileSystem.get(new URI("hdfs://IP地址:9000"),new Configuration(),"root");
    }
    
    /**
     * 判断是否是文件或目录
     */
    @Test
    public void testfilesFile() throws Exception {
        String  src = "hdfs://IP地址:9000/文件路径或目录";
        boolean flag = fs.isDirectory(new Path(src));
        if(flag){
            System.out.println("是目录");
        }else if(fs.isFile(new Path(src))){
            System.out.println("是文件");
        }else{
            System.out.println("不存在");
        }
    }
    
    /**
     * 关闭HDFS
     */
    @After
    public void close()throws  Exception{
       fs.close();
    }
}

文件重命名

public class HdfsTest {
    private FileSystem fs = null;
    
    /**
     * 连接HDFS
     */
    @Before
    public void init() throws Exception {
        fs = FileSystem.get(new URI("hdfs://IP地址:9000"),new Configuration(),"root");
    }
    
    /**
     * 文件重命名
     */
    public void testrenameFile()  throws Exception{
        String oldname = "hdfs://IP地址:9000/原文件路径";
        String newname = "hdfs://IP地址:9000/新文件路径";
        fs.rename(new Path(oldname), new Path(newname));
    }
    
    /**
     * 关闭HDFS
     */
    @After
    public void close()throws  Exception{
       fs.close();
    }
}

文件移动

public class HdfsTest {
    private FileSystem fs = null;
    
    /**
     * 连接HDFS
     */
    @Before
    public void init() throws Exception {
        fs = FileSystem.get(new URI("hdfs://IP地址:9000"),new Configuration(),"root");
    }
    
    /**
     * HDFS上的文件移动到本地
     */
    @Test
    public void testmovetolocalFile() throws Exception {
        String  src = "hdfs://IP地址:9000/文件路径";
        String  desc = "/本地路径";
        fs.moveToLocalFile(new Path(src), new Path(desc));
    }
    /**
     * 本地文件移动到HDFS上
     */
    @Test
    public void testmovetohdfsFile() throws Exception {
        String  src = "/本地文件路径";
        String  desc = "hdfs://IP地址:9000/路径";
        fs.moveFromLocalFile(new Path(src), new Path(desc));
    }
    
    /**
     * 关闭HDFS
     */
    @After
    public void close()throws  Exception{
       fs.close();
    }
}

上传文件

public class HdfsTest {
    private FileSystem fs = null;
    
    /**
     * 连接HDFS
     */
    @Before
    public void init() throws Exception {
        fs = FileSystem.get(new URI("hdfs://IP地址:9000"),new Configuration(),"root");
    }
    
    /**
     * 上传文件
     */
    public void testUploadFile()throws Exception {
        String src="/本地文件路径";
        String desc= "/HDFS上的路径";
        fs.copyFromLocalFile(new Path(src), new Path(desc));
    }
    
    /**
     * 关闭HDFS
     */
    @After
    public void close()throws  Exception{
       fs.close();
    }
}

下载文件

public class HdfsTest {
    private FileSystem fs = null;
    
    /**
     * 连接HDFS
     */
    @Before
    public void init() throws Exception {
        fs = FileSystem.get(new URI("hdfs://IP地址:9000"),new Configuration(),"root");
    }
    
    /**
     * 下载文件
     */
    public void testDownloadFile() throws Exception{
        String  src= "/HDFS上的文件路径";
        String  desc="/本地路径";
        fs.copyToLocalFile(new Path(src), new Path(desc));
    }
    
    /**
     * 关闭HDFS
     */
    @After
    public void close()throws  Exception{
       fs.close();
    }
}

文件合并

public class HdfsTest {
    public static void main(String[] args) {
        Configuration conf = new Configuration();
        try {
            // 获得hdfs文件系统的对象
            FileSystem hdfs = FileSystem.get(conf);
            // 获得本地文件系统对象
            FileSystem local = FileSystem.getLocal(conf);

            // 设定输入目录
            Path inputDir = new Path("HDFS上的路径");
            // 设定输出目录
            Path hdfsFile = new Path("/本地路径");
            // 获得目录中的文件列表
            FileStatus [] inputFiles = local.listStatus(inputDir);
            // 生成HDFS输出流
            FSDataOutputStream out = hdfs.create(hdfsFile);  
            for(int i= 0;i<inputFiles.length;i++){
                System.out.println(inputFiles[i].getPath().getName());
                FSDataInputStream in = local.open(inputFiles[i].getPath());
                byte[] buffer = new byte[256];
                int bytesRead = 0;
                while((bytesRead = in.read(buffer))>0){
                    out.write(buffer,0,bytesRead);
                }
                in.close();
            }
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件内容追加

public class HdfsTest {
    public static void main(String[]  args) throws Exception {
        Configuration con = new Configuration();
        con.setBoolean("dfs.support.append", true);
        // 初始化 FileSystem
        FileSystem  fs = FileSystem.get(new URI("hdfs://IP地址:9000"),con,"root");
        
        // 定义本地文件输入文件路径
        String inpath = "本地文件路径";
        // 定义追加到hadoop上的文件路径
        String hdfsFilePath="/HDFS上的文件路径";
        // 判断是否在hdfs上存在该文件
        boolean isFile=fs.isFile(new Path(hdfsFilePath));
        if(!isFile){
            fs.createNewFile(new Path(hdfsFilePath));
        }
        
        // 定义输入流
        InputStream  in = new BufferedInputStream(new FileInputStream(inpath));
        OutputStream out =  fs.append(new Path(hdfsFilePath));
        // 开始传输
        IOUtils.copyBytes(in, out, 4096, true);
    }
}

编程小吉

关注

5
点赞
踩
26

收藏

觉得还不错? 一键收藏
打赏
4
评论
Hadoop技术之HDFS

HDFS基础1.HDFS的相关概述2.HDFS的相关概念3.HDFS的体系结构4.HDFS的存储原理5.HDFS的数据读写6.HDFS 常用的Shell命令操作7.HDFS 常用的Java API操作1.HDFS的相关概述分布式文件系统把文件分布存储到多个计算机节点上，成千上万的计算机节点构成计算机集群。分布式文件系统在物理结构上是由计算机集群中的多个节点构成的，这些节点分为两类：“主节点”(Master Node)或者也被称为“名称结点”(NameNode)“从节点”(Slave No
复制链接

扫一扫