102_HDFS分布式文件系统

1 HDFS简介
2 HDFS的重要概念
3 HDFS架构
4 HDFS 客户端操作
- 4.1 Shell命令行操作HDFS
- 4.2 JAVA客户端
  - 4.2.1 客户端环境准备
  - 4.2.2 HDFS的API操作
5 HDFS读写解析
- 5.1 HDFS读数据流程
- 5.2 HDFS写数据流程
6 NN与2NN
7 NN故障处理
8 Hadoop的限额与归档以及集群安全模式
9 日志采集综合案例
- 9.1 需求分析
- 9.2 代码实现

1 HDFS简介

HDFS（全称：Hadoop Distribute File System，Hadoop 分布式文件系统）是 Hadoop 核心组
成，是分布式存储服务。
分布式文件系统横跨多台计算机，在大数据时代有着广泛的应用前景，它们为存储和处理超大规模
数据提供所需的扩展能力。
HDFS是分布式文件系统中的一种。

2 HDFS的重要概念

HDFS 通过统一的命名空间目录树来定位文件；另外，它是分布式的，由很多服务器联合起来实现
其功能，集群中的服务器有各自的角色（分布式本质是拆分，各司其职）。

典型的 Master/Slave 架构

HDFS 的架构是典型的 Master/Slave 结构；
HDFS集群往往是一个NameNode（HA架构会有两个NameNode）+多个DataNode组
成；
NameNode是集群的主节点，DataNode是集群的从节点。
分块存储（block机制）

HDFS 中的文件在物理上是分块存储（block）的，块的大小可以通过配置参数来规定；
Hadoop2.x版本中默认的block大小是128M；
命名空间（NameSpace）

HDFS 支持传统的层次型文件组织结构。用户或者应用程序可以创建目录，然后将文件保存在这些
目录里。文件系统名字空间的层次结构和大多数现有的文件系统类似：用户可以创建、删除、移动
或重命名文件。
Namenode 负责维护文件系统的名字空间，任何对文件系统名字空间或属性的修改都将被Namenode 记录下来。
HDFS提供给客户单一个抽象目录树，访问形式：hdfs://namenode 的 hostname:port/test/input
hdfs://linux121:9000/test/input
NameNode元数据管理

我们把目录结构及文件分块位置信息叫做元数据。
NameNode的元数据记录每一个文件所对应的block信息（block的id,以及所在的DataNode节点
的信息）。
DataNode数据存储

文件的各个 block 的具体存储管理由 DataNode 节点承担。一个block会有多个DataNode来存储，DataNode会定时向NameNode来汇报自己持有的block信息。
副本机制

为了容错，文件的所有 block 都会有副本。每个文件的 block 大小和副本系数都是可配置的。应用程序可以指定某个文件的副本数目。副本系数可以在文件创建的时候指定，也可以在之后改变。副本数量默认是3个。
一次写入，多次读出

HDFS 是设计成适应一次写入，多次读出的场景，且不支持文件的随机修改。（支持追加写入，不只支持随机更新）
正因为如此，HDFS 适合用来做大数据分析的底层存储服务，并不适合用来做网盘等应用（修改不方便，延迟大，网络开销大，成本太高）

3 HDFS架构

NameNode(nn):Hdfs集群的管理者，Master
- 维护管理Hdfs的名称空间（NameSpace）
- 维护副本策略
- 记录文件块（Block）的映射信息
- 负责处理客户端读写请求
DataNode:NameNode下达命令，DataNode执行实际操作，是Slave节点。
- 保存实际的数据块
- 负责数据块的读写
Client:客户端
- 上传文件到HDFS的时候，Client负责将文件切分成Block,然后进行上传
- 请求NameNode交互，获取文件的位置信息
- 读取或写入文件，与DataNode交互
- Client可以使用一些命令来管理HDFS或者访问HDFS

4 HDFS 客户端操作

4.1 Shell命令行操作HDFS

4.1.1 基本语法

hadoop fs 具体命令

hdfs dfs 具体命令

4.2.2 命令大全

[root@linux123 ~]# hdfs dfs
Usage: hadoop fs [generic options]
	[-appendToFile <localsrc> ... <dst>]
	[-cat [-ignoreCrc] <src> ...]
	[-checksum <src> ...]
	[-chgrp [-R] GROUP PATH...]
	[-chmod [-R] <MODE[,MODE]... | OCTALMODE> PATH...]
	[-chown [-R] [OWNER][:[GROUP]] PATH...]
	[-copyFromLocal [-f] [-p] [-l] [-d] <localsrc> ... <dst>]
	[-copyToLocal [-f] [-p] [-ignoreCrc] [-crc] <src> ... <localdst>]
	[-count [-q] [-h] [-v] [-t [<storage type>]] [-u] [-x] <path> ...]
	[-cp [-f] [-p | -p[topax]] [-d] <src> ... <dst>]
	[-createSnapshot <snapshotDir> [<snapshotName>]]
	[-deleteSnapshot <snapshotDir> <snapshotName>]
	[-df [-h] [<path> ...]]
	[-du [-s] [-h] [-x] <path> ...]
	[-expunge]
	[-find <path> ... <expression> ...]
	[-get [-f] [-p] [-ignoreCrc] [-crc] <src> ... <localdst>]
	[-getfacl [-R] <path>]
	[-getfattr [-R] {-n name | -d} [-e en] <path>]
	[-getmerge [-nl] [-skip-empty-file] <src> <localdst>]
	[-help [cmd ...]]
	[-ls [-C] [-d] [-h] [-q] [-R] [-t] [-S] [-r] [-u] [<path> ...]]
	[-mkdir [-p] <path> ...]
	[-moveFromLocal <localsrc> ... <dst>]
	[-moveToLocal <src> <localdst>]
	[-mv <src> ... <dst>]
	[-put [-f] [-p] [-l] [-d] <localsrc> ... <dst>]
	[-renameSnapshot <snapshotDir> <oldName> <newName>]
	[-rm [-f] [-r|-R] [-skipTrash] [-safely] <src> ...]
	[-rmdir [--ignore-fail-on-non-empty] <dir> ...]
	[-setfacl [-R] [{-b|-k} {-m|-x <acl_spec>} <path>]|[--set <acl_spec> <path>]]
	[-setfattr {-n name [-v value] | -x name} <path>]
	[-setrep [-R] [-w] <rep> <path> ...]
	[-stat [format] <path> ...]
	[-tail [-f] <file>]
	[-test -[defsz] <path>]
	[-text [-ignoreCrc] <src> ...]
	[-touchz <path> ...]
	[-truncate [-w] <length> <path> ...]
	[-usage [cmd ...]]

Generic options supported are:
-conf <configuration file>        specify an application configuration file
-D <property=value>               define a value for a given property
-fs <file:///|hdfs://namenode:port> specify default filesystem URL to use, overrides 'fs.defaultFS' property from configurations.
-jt <local|resourcemanager:port>  specify a ResourceManager
-files <file1,...>                specify a comma-separated list of files to be copied to the map reduce cluster
-libjars <jar1,...>               specify a comma-separated list of jar files to be included in the classpath
-archives <archive1,...>          specify a comma-separated list of archives to be unarchived on the compute machines

4.3.3 HDFS命令演示

启动Hadoop集群（方便后续的测试）

[root@linux121 hadoop-2.9.2]$ sbin/start-dfs.sh
[root@linux122 hadoop-2.9.2]$ sbin/start-yarn.sh

-help: 输出这个命令参数

[root@linux121 hadoop-2.9.2]$ hadoop fs -help rm

[root@linux121 hadoop-2.9.2]$ hadoop fs -ls /

[root@linux121 hadoop-2.9.2]$ hadoop fs -mkdir -p /lagou/bigdata

-moveFromLocal：从本地剪切粘贴到HDFS

[root@linux121 hadoop-2.9.2]$ touch hadoop.txt

[root@linux121 hadoop-2.9.2]$ hadoop fs  -moveFromLocal ./hadoop.txt
/lagou/bigdata

-appendToFile：追加一个文件到已经存在的文件末尾

[root@linux121 hadoop-2.9.2]$ touch hdfs.txt
[root@linux121 hadoop-2.9.2]$ vi hdfs.txt

在hdfs.txt中输入：namenode datanode block replication

[root@linux121 hadoop-2.9.2]$ hadoop fs -appendToFile hdfs.txt
/lagou/bigdata/hadoop.txt

-cat：显示文件内容

[root@linux121 hadoop-2.9.2]$ hadoop fs -cat /lagou/bigdata/hadoop.txt

-chgrp 、-chmod、-chown：Linux文件系统中的用法一样，修改文件所属权限

[root@linux121 hadoop-2.9.2]$ hadoop fs -chmod 666 /lagou/bigdata/hadoop.txt
[root@linux121 hadoop-2.9.2]$ hadoop fs -chown root:root /lagou/bigdata/hadoop.txt

-copyFromLocal：从本地文件系统中拷贝文件到HDFS路径去

[root@linux121 hadoop-2.9.2]$ hadoop fs -copyFromLocal README.txt /

-copyToLocal：从HDFS拷贝到本地

[root@linux121 hadoop-2.9.2]$ hadoop fs -copyToLocal /lagou/bigdata/hadoop.txt
./

-cp ：从HDFS的一个路径拷贝到HDFS的另一个路径

[root@linux121 hadoop-2.9.2]$ hadoop fs -cp /lagou/bigdata/hadoop.txt /hdfs.txt

[root@linux121 hadoop-2.9.2]$ hadoop fs -mv /hdfs.txt /lagou/bigdata/

-get：等同于copyToLocal，就是从HDFS下载文件到本地

[root@linux121 hadoop-2.9.2]$ hadoop fs -get /lagou/bigdata/hadoop.txt ./

-put：等同于copyFromLocal

[root@linux121 hadoop-2.9.2]$ hadoop fs -mkdir -p /user/root/test/ 

[root@linux121 hadoop-2.9.2]$ vim yarn.txt #本地文件系统创建yarn.txt
resourcemanager nodemanager

[root@linux121 hadoop-2.9.2]$ hadoop fs -put ./yarn.txt /user/root/test/

-tail：显示一个文件的末尾

[root@linux121 hadoop-2.9.2]$ hadoop fs -tail /user/root/test/yarn.txt

-rm：删除文件或文件夹

[root@linux121 hadoop-2.9.2]$ hadoop fs -rm /user/root/test/yarn.txt

[root@linux121 hadoop-2.9.2]$ hadoop fs -mkdir /test
[root@linux121 hadoop-2.9.2]$ hadoop fs -rmdir /test

-du：统计文件夹的大小信息

[root@linux121 hadoop-2.9.2]$ hadoop fs -du -s -h /user/root/test
[root@linux121 hadoop-2.9.2]$ hadoop fs -du -h /user/root/test

-setrep：设置HDFS中文件的副本数量

[root@linux121 hadoop-2.9.2]$ hadoop fs -setrep 10 /lagou/bigdata/hadoop.txt

HDFS副本数量：

这里设置的副本数只是记录在NameNode的元数据中，是否真的会有这么多副本，还得看DataNode的
数量。因为目前只有3台设备，最多也就3个副本，只有节点数的增加到10台时，副本数才能达到10。

4.2 JAVA客户端

4.2.1 客户端环境准备

将hadoop-2.9.2.tar.gz安装包解压到非中文路径（例如：D:\software\hadoop-2.9.2）。

配置HADOOP_HOME环境变量

配置Path环境变量

创建一个Maven工程ClientDemo
导入相应的依赖坐标+日志配置文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>ClientDemo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-client-->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-hdfs -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-hdfs</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
</project>

为了便于控制程序运行打印的日志数量，需要在项目的src/main/resources目录下，新建一个文件，命
名为“log4j.properties”，文件内容：

log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/spring.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

创建包名：com.lagou.hdfs
创建HdfsClient类

package com.lagou.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.fs.permission.FsPermission;
import org.junit.Test;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class HdfsClient {
    @Test
    public void testMkdirs() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");

        //2.创建目录
        fs.mkdirs(new Path("/test04"));

        //3.关闭资源
        fs.close();
    }
}

遇到问题：

如果不指定操作HDFS集群的用户信息，默认是获取当前操作系统的用户信息，出现权限被拒绝的问
题，报错如下：

4.2.2 HDFS的API操作

4.2.2.1 上传文件

编写源代码

package com.lagou.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.fs.permission.FsPermission;
import org.junit.Test;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class HdfsClientTest {
    @Test
    public void testCopyFromLocalFile() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        configuration.set("dfs.replication", "2");
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");
        //2.创建目录
        fs.copyFromLocalFile(
                new Path("H:\\hadoop\\learningCode\\mapreduce\\ClientDemo\\lagou.txt"),
                new Path("/lagou.txt")
        );

        //3.关闭资源
        fs.close();
    }
}

将hdfs-site.xml拷贝到项目的根目录下

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
    <property>
        <name>dfs.replication</name> 
        <value>1</value>
    </property>
</configuration>

参数优先级

参数优先级排序：（1）代码中设置的值 >（2）用户自定义配置文件 >（3）服务器的默认配置

4.2.2.2 下载文件

package com.lagou.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.fs.permission.FsPermission;
import org.junit.Test;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class HdfsClientTest {
    @Test
    public void testCopyToLocalFile() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");
        //2.创建目录
        fs.copyToLocalFile(
                false, //是否删除原文件
                new Path("/lagou.txt"), //要下载的hdfs文件路径
                new Path("H:\\hadoop\\learningCode\\mapreduce\\ClientDemo\\lagou_copy.txt"), //文件本地路径
                true //是否开启文件校验
        );

        //3.关闭资源
        fs.close();
    }
}

4.2.2.3 删除文件/文件夹

package com.lagou.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.fs.permission.FsPermission;
import org.junit.Test;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class HdfsClientTest {
    @Test
    public void testDelete() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");
        //2.执行删除
        fs.delete(new Path("/test04"), true);

        //3.关闭资源
        fs.close();
    }
}

4.2.2.4 查看文件名称、权限、长度、块信息

package com.lagou.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.fs.permission.FsPermission;
import org.junit.Test;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class HdfsClient {
    @Test
    public void testListFiles() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");
        //2.获取文件详情
        RemoteIterator<LocatedFileStatus> listFiles = fs.listFiles(new Path("/"), true);
        while (listFiles.hasNext()) {
            LocatedFileStatus status = listFiles.next();
            String name = status.getPath().getName(); //文件名称
            long len = status.getLen(); //文件长度(大小)
            FsPermission permission = status.getPermission(); //文件权限
            String group = status.getGroup(); //文件所属分组

            System.out.println("文件名称:" + name);
            System.out.println("文件长度(大小):" + len);
            System.out.println("文件权限:" + permission);
            System.out.println("文件所属分组:" + group);

            BlockLocation[] blockLocations = status.getBlockLocations();

            for (BlockLocation blockLocation : blockLocations) {
                //获取块存储的主机节点
                String[] hosts = blockLocation.getHosts();

                for (String host : hosts) {
                    System.out.println(host);
                }
            }
            System.out.println("-----------------------------------");
        }

        //3.关闭资源
        fs.close();
    }
}

4.2.2.5 文件夹判断

package com.lagou.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.fs.permission.FsPermission;
import org.junit.Test;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class HdfsClient {
    @Test //文件夹判断
    public void testListStatus() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");
        //2.判断是文件还是文件夹
        FileStatus[] listStatus = fs.listStatus(new Path("/"));

        for (FileStatus fileStatus : listStatus) {
            System.out.println(fileStatus.isFile() ? "文件：" + fileStatus.getPath().getName() : "文件夹：" + fileStatus.getPath().getName());
        }

        //3.关闭资源
        fs.close();
    }
}

4.2.2.6 `I/O`流操作HDFS

以上我们使用的API操作都是HDFS系统框架封装好的。我们自己也可以采用IO流的方式实现文件的上传
和下载。

4.2.2.6.1 文件上传

需求：把本地的lagou.txt文件上传到HDFS根目录
编写代码

package com.lagou.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.fs.permission.FsPermission;
import org.apache.hadoop.io.IOUtils;
import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class HdfsClient {
    @Test //文件夹判断
    public void putFileToHDFS() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");
        //2.创建输入流
        FileInputStream fis = new FileInputStream(new File("lagou2.txt"));

        //3.获取输入流
        FSDataOutputStream fos = fs.create(new Path("/lagou_io.txt"));

        //4.流对拷
        IOUtils.copyBytes(fis, fos, configuration);

        //5.关闭资源
        IOUtils.closeStream(fos);
        IOUtils.closeStream(fis);
        fs.close();
    }
}

4.2.2.6.2 文件下载

需求：从HDFS上下载lagou_io.txt文件到本地磁盘上
编写代码

package com.lagou.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.fs.permission.FsPermission;
import org.apache.hadoop.io.IOUtils;
import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class HdfsClient {
    @Test //IO流文件下载
    public void getFileFromHDFS() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");

        //2.获取输入流
        FSDataInputStream fis = fs.open(new Path("/lagou_io.txt"));

        //3.获取输出流
        FileOutputStream fos = new FileOutputStream(new File("lahou2_io.txt"));

        //4.流对拷
        IOUtils.copyBytes(fis, fos, configuration);

        //5.关闭资源
        IOUtils.closeStream(fos);
        IOUtils.closeStream(fis);
        fs.close();
    }
}

4.2.2.6.3 seek定位读取

需求：将HDFS上的lagou.txt的内容在控制台输出两次
编写代码

package com.lagou.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.fs.permission.FsPermission;
import org.apache.hadoop.io.IOUtils;
import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class HdfsClient {
    @Test //seek定位读取
    public void readFileBySeek() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");

        //2.打开输入流，读取数据输出到控制台
        FSDataInputStream in = null;
        try {
            in = fs.open(new Path("/lagou.txt"));
            IOUtils.copyBytes(in, System.out, 4096, false);
            in.seek(0); //从头再次读取
            IOUtils.copyBytes(in, System.out, 4096, false);
        } finally {
            IOUtils.closeStream(in);
        }

        //3.关闭资源
        fs.close();
    }
}

注意事项

windows解压安装Hadoop后，在调用相关API操作HDFS集群时可能会报错，这是由于Hadoop安
装缺少windows操作系统相关文件所致，如下图：

解决方案：
从资料文件夹中找到winutils.exe拷贝放到windows系统Hadoop安装目录的bin目录下即可！！

HDFS文件系统权限问题

hdfs的文件权限机制与linux系统的文件权限机制类似。

r:read w:write x:execute 权限x对于文件表示忽略，对于文件夹表示是否有权限访问其内容。

如果linux系统用户zhangsan使用hadoop命令创建一个文件，那么这个文件在HDFS当中的owner
就是zhangsan；HDFS文件权限的目的，防止好人做错事，而不是阻止坏人做坏事。HDFS相信你告诉我你是谁，
你就是谁。

解决方案：
- 指定用户信息获取FileSystem对象
- 关闭HDFS集群权限校验
```
vim hdfs-site.xml #添加如下属性

<property>
	<name>dfs.permissions</name>
	<value>true</value>
</property>

# 修改完成之后要分发到其它节点，同时要重启HDFS集群
```
- 基于HDFS权限本身比较鸡肋的特点，我们可以彻底放弃HDFS的权限校验，如果生产环境中
  我们可以考虑借助kerberos以及sentry等安全框架来管理大数据集群安全。所以我们直接修
  改HDFS的根目录权限为777。
```
hdfs dfs -chmod -R 777 /
```

代码优化

原代码：HdfsClient.java

package com.lagou.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.fs.permission.FsPermission;
import org.apache.hadoop.io.IOUtils;
import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class HdfsClient {
    @Test //建文件夹
    public void testMkdirs() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");

        //2.创建目录
        fs.mkdirs(new Path("/test04"));

        //3.关闭资源
        fs.close();
    }

    @Test //上传文件
    public void testCopyFromLocalFile() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        configuration.set("dfs.replication", "2");
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");
        //2.创建目录
        fs.copyFromLocalFile(
                new Path("H:\\hadoop\\learningCode\\mapreduce\\ClientDemo\\lagou.txt"),
                new Path("/test01/lagou.txt")
        );

        //3.关闭资源
        fs.close();
    }

    @Test //下载文件
    public void testCopyToLocalFile() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");
        //2.创建目录
        fs.copyToLocalFile(
                false, //是否删除原文件
                new Path("/lagou.txt"), //要下载的hdfs文件路径
                new Path("H:\\hadoop\\learningCode\\mapreduce\\ClientDemo\\lagou_copy.txt"), //文件本地路径
                true //是否开启文件校验
        );

        //3.关闭资源
        fs.close();
    }

    @Test //删除文件/文件夹
    public void testDelete() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");
        //2.执行删除
        fs.delete(new Path("/test04"), true);

        //3.关闭资源
        fs.close();
    }

    @Test //查看文件名称、权限、长度、块信息
    public void testListFiles() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");
        //2.获取文件详情
        RemoteIterator<LocatedFileStatus> listFiles = fs.listFiles(new Path("/"), true);
        while (listFiles.hasNext()) {
            LocatedFileStatus status = listFiles.next();
            String name = status.getPath().getName(); //文件名称
            long len = status.getLen(); //文件长度(大小)
            FsPermission permission = status.getPermission(); //文件权限
            String group = status.getGroup(); //文件所属分组

            System.out.println("文件名称:" + name);
            System.out.println("文件长度(大小):" + len);
            System.out.println("文件权限:" + permission);
            System.out.println("文件所属分组:" + group);

            BlockLocation[] blockLocations = status.getBlockLocations();

            for (BlockLocation blockLocation : blockLocations) {
                //获取块存储的主机节点
                String[] hosts = blockLocation.getHosts();

                for (String host : hosts) {
                    System.out.println(host);
                }
            }
            System.out.println("-----------------------------------");
        }

        //3.关闭资源
        fs.close();
    }

    @Test //文件夹判断
    public void testListStatus() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");
        //2.判断是文件还是文件夹
        FileStatus[] listStatus = fs.listStatus(new Path("/"));

        for (FileStatus fileStatus : listStatus) {
            System.out.println(fileStatus.isFile() ? "文件：" + fileStatus.getPath().getName() : "文件夹：" + fileStatus.getPath().getName());
        }

        //3.关闭资源
        fs.close();
    }

    @Test //IO流文件上传
    public void putFileToHDFS() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");
        //2.创建输入流
        FileInputStream fis = new FileInputStream(new File("lagou2.txt"));

        //3.获取输入流
        FSDataOutputStream fos = fs.create(new Path("/lagou_io.txt"));

        //4.流对拷
        IOUtils.copyBytes(fis, fos, configuration);

        //5.关闭资源
        IOUtils.closeStream(fos);
        IOUtils.closeStream(fis);
        fs.close();
    }

    @Test //IO流文件下载
    public void getFileFromHDFS() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");

        //2.获取输入流
        FSDataInputStream fis = fs.open(new Path("/lagou_io.txt"));

        //3.获取输出流
        FileOutputStream fos = new FileOutputStream(new File("lahou2_io.txt"));

        //4.流对拷
        IOUtils.copyBytes(fis, fos, configuration);

        //5.关闭资源
        IOUtils.closeStream(fos);
        IOUtils.closeStream(fis);
        fs.close();
    }

    @Test //seek定位读取
    public void readFileBySeek() throws IOException, URISyntaxException, InterruptedException {
        //1.获取文件系统
        Configuration configuration = new Configuration();
        FileSystem fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");

        //2.打开输入流，读取数据输出到控制台
        FSDataInputStream in = null;
        try {
            in = fs.open(new Path("/lagou.txt"));
            IOUtils.copyBytes(in, System.out, 4096, false);
            in.seek(0); //从头再次读取
            IOUtils.copyBytes(in, System.out, 4096, false);
        } finally {
            IOUtils.closeStream(in);
        }

        //3.关闭资源
        fs.close();
    }
}

优化后的代码：HdfsClientTest.java

package com.lagou.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.fs.permission.FsPermission;
import org.apache.hadoop.io.IOUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class HdfsClientTest {
    Configuration configuration = null;
    FileSystem fs = null;

    @Before
    public void init() throws URISyntaxException, IOException, InterruptedException {
        //获取hadoop集群的Configuration对象
        configuration = new Configuration();
        //根据Configuration对象获取FileSystem对象
        fs = FileSystem.get(new URI("hdfs://linux121:9000"), configuration, "root");
    }

    @After
    public void destory() throws IOException {
        //释放FileSystem对象（类似数据库连接）
        fs.close();
    }

    @Test //建文件夹
    public void testMkdirs() throws IOException {
        //创建目录
        fs.mkdirs(new Path("/test04"));
    }

    @Test //上传文件
    public void testCopyFromLocalFile() throws IOException {
        //上传文件
        fs.copyFromLocalFile(
                new Path("H:\\hadoop\\learningCode\\mapreduce\\ClientDemo\\lagou.txt"),
                new Path("/test01/lagou.txt")
        );
    }

    @Test //下载文件
    public void testCopyToLocalFile() throws IOException {
        //创建目录
        fs.copyToLocalFile(
                false, //是否删除原文件
                new Path("/lagou.txt"), //要下载的hdfs文件路径
                new Path("H:\\hadoop\\learningCode\\mapreduce\\ClientDemo\\lagou_copy.txt"), //文件本地路径
                true //是否开启文件校验
        );
    }

    @Test //删除文件/文件夹
    public void testDelete() throws IOException {
        //执行删除
        fs.delete(new Path("/test04"), true);
    }

    @Test //查看文件名称、权限、长度、块信息
    public void testListFiles() throws IOException {
        //获取文件详情
        RemoteIterator<LocatedFileStatus> listFiles = fs.listFiles(new Path("/"), true);
        while (listFiles.hasNext()) {
            LocatedFileStatus status = listFiles.next();
            String name = status.getPath().getName(); //文件名称
            long len = status.getLen(); //文件长度(大小)
            FsPermission permission = status.getPermission(); //文件权限
            String group = status.getGroup(); //文件所属分组

            System.out.println("文件名称:" + name);
            System.out.println("文件长度(大小):" + len);
            System.out.println("文件权限:" + permission);
            System.out.println("文件所属分组:" + group);

            BlockLocation[] blockLocations = status.getBlockLocations();

            for (BlockLocation blockLocation : blockLocations) {
                //获取块存储的主机节点
                String[] hosts = blockLocation.getHosts();

                for (String host : hosts) {
                    System.out.println(host);
                }
            }
            System.out.println("-----------------------------------");
        }
    }

    @Test //文件夹判断
    public void testListStatus() throws IOException {
        //判断是文件还是文件夹
        FileStatus[] listStatus = fs.listStatus(new Path("/"));

        for (FileStatus fileStatus : listStatus) {
            System.out.println(fileStatus.isFile() ? "文件：" + fileStatus.getPath().getName() : "文件夹：" + fileStatus.getPath().getName());
        }
    }

    @Test //IO流文件上传
    public void putFileToHDFS() throws IOException {
        //创建输入流
        FileInputStream fis = new FileInputStream(new File("lagou2.txt"));

        //获取输入流
        FSDataOutputStream fos = fs.create(new Path("/lagou_io.txt"));

        //流对拷
        IOUtils.copyBytes(fis, fos, configuration);

        //关闭通道
        IOUtils.closeStream(fos);
        IOUtils.closeStream(fis);
    }

    @Test //IO流文件下载
    public void getFileFromHDFS() throws IOException {
        //获取输入流
        FSDataInputStream fis = fs.open(new Path("/lagou_io.txt"));

        //获取输出流
        FileOutputStream fos = new FileOutputStream(new File("lahou2_io.txt"));

        //流对拷
        IOUtils.copyBytes(fis, fos, configuration);

        //关闭通道
        IOUtils.closeStream(fos);
        IOUtils.closeStream(fis);
    }

    @Test //seek定位读取
    public void readFileBySeek() throws IOException {
        //打开输入流，读取数据输出到控制台
        FSDataInputStream in = null;
        try {
            in = fs.open(new Path("/lagou.txt"));
            IOUtils.copyBytes(in, System.out, 4096, false);
            in.seek(0); //从头再次读取
            IOUtils.copyBytes(in, System.out, 4096, false);
        } finally {
            IOUtils.closeStream(in);
        }
    }
}

5 HDFS读写解析

5.1 HDFS读数据流程

客户端通过Distributed FileSystem向NameNode请求下载文件，NameNode通过查询元数据，
找到文件块所在的DataNode地址。
（按照就近原则，随机）挑选一台DataNode服务器，请求读取数据。
DataNode开始传输数据给客户端（从磁盘里面读取数据输入流，以Packet为单位来做校验）。
客户端以Packet为单位接收，先在本地缓存，然后写入目标文件。

5.2 HDFS写数据流程

客户端通过Distributed FileSystem模块向NameNode请求上传文件，NameNode对请求信息进行校验，包括检查目标文件是否已存在，父目录是否存在。
NameNode返回校验结果，告知客户端是否可以上传。
客户端请求第一个Block上传到哪几个DataNode服务器上。
NameNode返回3个DataNode节点，分别为dn1、dn2、dn3。
客户端通过FSDataOutputStream模块向dn1请求上传数据，dn1收到请求会继续调用dn2，然后
dn2调用dn3，将这个通信管道建立完成。
dn1、dn2、dn3逐级应答客户端。
客户端开始往dn1上传第一个Block（先从磁盘读取数据放到一个本地内存缓存），以Packet为单
位，dn1收到一个Packet就会传给dn2，dn2传给dn3；dn1每传一个packet会放入一个确认队列
等待确认。
当一个Block传输完成之后，客户端再次请求NameNode上传第二个Block的服务器。（重复执行
3-7步）。

package com.lagou.hdfs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.fs.permission.FsPermission;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.util.Progressable;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class HdfsClientTest {
    Configuration configuration = null;
    FileSystem fs = null;
    @Test //验证Packet代码
    public void testUploadPacket() throws IOException {
        //准备读取本地文件的输入流
        final FileInputStream in = new FileInputStream(new File("lagou2_io.txt"));
        //准备好写出数据到hdfs的输出流
        final FSDataOutputStream out = fs.create(new Path("/lagou_io3.txt"), new Progressable() {
            public void progress() { //这个progress方法就是每传输64KB(packet)就会执行一次
                System.out.println("&");
            }
        });
        //实现流拷贝
        IOUtils.copyBytes(in, out, configuration); //默认关闭流选项是true，所以会自动关闭
        //关闭流
        IOUtils.closeStream(in);
        IOUtils.closeStream(out);
    }
}

6 NN与2NN

6.1 HDFS元数据管理机制

问题1：NameNode如何管理和存储元数据？
- 计算机中存储数据两种：内存或者是磁盘。
- 如果将元数据存储到磁盘，存储磁盘无法面对客户端对元数据信息的任意的快速低延迟的响应，但是安全性高；
- 如果将元数据存储到内存，可以高效的查询以及快速响应客户端的查询请求，但是数据保存在内
  存，如果断点，内存中的数据全部丢失。
- 所以hadoop的解决方案是：内存+磁盘
- NameNode内存 + FsImage的文件（磁盘）
问题2：磁盘和内存中元数据如何划分？两个数据一模一样，还是两个数据合并到一起才是一份完整的数据呢？
- 如果两边的数据一模一样，当client端对元数据进行增删改操作，则需要保证两份数据的一致性。当文件过大时FsImage文件操作起来效率会很低。
- 所以解决方案是 内存数据 + 磁盘数据 = 完整数据：NameNode引入了一个edits文件（日志文件：只能追加写入），edits文件记录的是client的增删改操作，不再选择让NameNode把数据dump出来形成FsImage文件（这种操作是比较消耗资源）。

元数据管理流程图：

第一阶段：NameNode启动
- 第一次启动NameNode格式化后，创建Fsimage和Edits文件。如果不是第一次启动，直接加载编辑日志和镜像文件到内存。
- 客户端对元数据进行增删改的请求。
- NameNode记录操作日志，更新滚动日志。
- NameNode在内存中对数据进行增删改。
第二阶段：Secondary NameNode工作
- Secondary NameNode询问NameNode是否需要CheckPoint。直接带回NameNode是否执行检查点操作结果。
- Secondary NameNode请求执行CheckPoint。
- NameNode滚动正在写的Edits日志。
- 将滚动前的编辑日志和镜像文件拷贝到Secondary NameNode。
- Secondary NameNode加载编辑日志和镜像文件到内存，并合并。
- 生成新的镜像文件fsimage.chkpoint。
- 拷贝fsimage.chkpoint到NameNode。
- NameNode将fsimage.chkpoint重新命名成fsimage。

6.2 Fsimage与Edits文件解析

NameNode在执行格式化之后，会在/opt/lagou/servers/hadoop-2.9.2/data/tmp/dfs/name/current
目录下产生如下文件

Fsimage文件：是namenode中关于元数据的镜像，一般称为检查点，这里包含了HDFS文件系统所有目录以及文件相关信息（Block数量，副本数量，权限等信息）
Edits文件：存储了客户端对HDFS文件系统所有的更新操作记录，Client对HDFS文件系统所有的更新操作都会被记录到Edits文件中（不包括查询操作）
seen_txid：该文件是保存了一个数字，数字对应着最后一个Edits文件名的数字
VERSION：该文件记录namenode的一些版本号信息，比如：CusterId,namespaceID等

6.2.1 Fsimage文件内容

官方地址: https://hadoop.apache.org/docs/r2.9.2/hadoop-project-dist/hadoop-hdfs/HdfsImageViewer.html

查看oiv和oev命令

基本语法

hdfs oiv -p 文件类型(xml) -i 镜像文件 -o 转换后文件输出路径

案例实操

[root@linux121 current]$ cd /opt/lagou/servers/hadoop-2.9.2/data/tmp/dfs/name/current
[root@linux121 current]$ hdfs oiv -p XML -i fsimage_0000000000000000265 -o /opt/lagou/servers/fsimage.xml
[root@linux121 current]$ cat /opt/lagou/servers/fsimage.xml

<?xml version="1.0"?>
<fsimage>
    <version>
        <layoutVersion>-63</layoutVersion>
        <onDiskVersion>1</onDiskVersion>
        <oivRevision>826afbeae31ca687bc2f8471dc841b66ed2c6704</oivRevision>
    </version>
    <NameSection>
        <namespaceId>962864096</namespaceId>
        <genstampV1>1000</genstampV1>
        <genstampV2>1004</genstampV2>
        <genstampV1Limit>0</genstampV1Limit>
        <lastAllocatedBlockId>1073741828</lastAllocatedBlockId>
        <txid>195</txid>
    </NameSection>
    <INodeSection>
        <lastInodeId>16400</lastInodeId>
        <numInodes>14</numInodes>
        <inode>
            <id>16385</id>
            <type>DIRECTORY</type>
            <name></name>
            <mtime>1625523180004</mtime>
            <permission>root:supergroup:0777</permission>
            <nsquota>9223372036854775807</nsquota>
            <dsquota>-1</dsquota>
        </inode>
        <inode>
            <id>16386</id>
            <type>DIRECTORY</type>
            <name>tmp</name>
            <mtime>1625210405237</mtime>
            <permission>root:supergroup:0777</permission>
            <nsquota>-1</nsquota>
            <dsquota>-1</dsquota>
        </inode>
        <inode>
            <id>16387</id>
            <type>DIRECTORY</type>
            <name>hadoop-yarn</name>
            <mtime>1625210405237</mtime>
            <permission>root:supergroup:0777</permission>
            <nsquota>-1</nsquota>
            <dsquota>-1</dsquota>
        </inode>
        <inode>
            <id>16388</id>
            <type>DIRECTORY</type>
            <name>staging</name>
            <mtime>1625210405237</mtime>
            <permission>root:supergroup:0777</permission>
            <nsquota>-1</nsquota>
            <dsquota>-1</dsquota>
        </inode>
        <inode>
            <id>16389</id>
            <type>DIRECTORY</type>
            <name>history</name>
            <mtime>1625210405363</mtime>
            <permission>root:supergroup:0777</permission>
            <nsquota>-1</nsquota>
            <dsquota>-1</dsquota>
        </inode>
        <inode>
            <id>16390</id>
            <type>DIRECTORY</type>
            <name>done</name>
            <mtime>1625210405237</mtime>
            <permission>root:supergroup:0777</permission>
            <nsquota>-1</nsquota>
            <dsquota>-1</dsquota>
        </inode>
        <inode>
            <id>16391</id>
            <type>DIRECTORY</type>
            <name>done_intermediate</name>
            <mtime>1625210405363</mtime>
            <permission>root:supergroup:1777</permission>
            <nsquota>-1</nsquota>
            <dsquota>-1</dsquota>
        </inode>
        <inode>
            <id>16392</id>
            <type>DIRECTORY</type>
            <name>test01</name>
            <mtime>1625498811585</mtime>
            <permission>root:supergroup:0777</permission>
            <nsquota>-1</nsquota>
            <dsquota>-1</dsquota>
        </inode>
        <inode>
            <id>16393</id>
            <type>DIRECTORY</type>
            <name>test02</name>
            <mtime>1625275594785</mtime>
            <permission>root:supergroup:0777</permission>
            <nsquota>-1</nsquota>
            <dsquota>-1</dsquota>
        </inode>
        <inode>
            <id>16394</id>
            <type>DIRECTORY</type>
            <name>test03</name>
            <mtime>1625275613778</mtime>
            <permission>root:supergroup:0777</permission>
            <nsquota>-1</nsquota>
            <dsquota>-1</dsquota>
        </inode>
        <inode>
            <id>16397</id>
            <type>FILE</type>
            <name>lagou.txt</name>
            <replication>2</replication>
            <mtime>1625276368372</mtime>
            <atime>1625524149107</atime>
            <preferredBlockSize>134217728</preferredBlockSize>
            <permission>root:supergroup:0777</permission>
            <blocks>
                <block>
                    <id>1073741826</id>
                    <genstamp>1002</genstamp>
                    <numBytes>717</numBytes>
                </block>
            </blocks>
            <storagePolicyId>0</storagePolicyId>
        </inode>
        <inode>
            <id>16398</id>
            <type>DIRECTORY</type>
            <name>test04</name>
            <mtime>1625498523411</mtime>
            <permission>root:supergroup:0777</permission>
            <nsquota>-1</nsquota>
            <dsquota>-1</dsquota>
        </inode>
        <inode>
            <id>16399</id>
            <type>FILE</type>
            <name>lagou.txt</name>
            <replication>2</replication>
            <mtime>1625498812642</mtime>
            <atime>1625498811585</atime>
            <preferredBlockSize>134217728</preferredBlockSize>
            <permission>root:supergroup:0777</permission>
            <blocks>
                <block>
                    <id>1073741827</id>
                    <genstamp>1003</genstamp>
                    <numBytes>717</numBytes>
                </block>
            </blocks>
            <storagePolicyId>0</storagePolicyId>
        </inode>
        <inode>
            <id>16400</id>
            <type>FILE</type>
            <name>lagou_io.txt</name>
            <replication>3</replication>
            <mtime>1625523180575</mtime>
            <atime>1625523180004</atime>
            <preferredBlockSize>134217728</preferredBlockSize>
            <permission>root:supergroup:0777</permission>
            <blocks>
                <block>
                    <id>1073741828</id>
                    <genstamp>1004</genstamp>
                    <numBytes>4866</numBytes>
                </block>
            </blocks>
            <storagePolicyId>0</storagePolicyId>
        </inode>
    </INodeSection>
    <INodeReferenceSection></INodeReferenceSection>
    <SnapshotSection>
        <snapshotCounter>0</snapshotCounter>
        <numSnapshots>0</numSnapshots>
    </SnapshotSection>
    <INodeDirectorySection>
        <directory>
            <parent>16385</parent>
            <child>16397</child>
            <child>16400</child>
            <child>16392</child>
            <child>16393</child>
            <child>16394</child>
            <child>16398</child>
            <child>16386</child>
        </directory>
        <directory>
            <parent>16386</parent>
            <child>16387</child>
        </directory>
        <directory>
            <parent>16387</parent>
            <child>16388</child>
        </directory>
        <directory>
            <parent>16388</parent>
            <child>16389</child>
        </directory>
        <directory>
            <parent>16389</parent>
            <child>16390</child>
            <child>16391</child>
        </directory>
        <directory>
            <parent>16392</parent>
            <child>16399</child>
        </directory>
    </INodeDirectorySection>
    <FileUnderConstructionSection></FileUnderConstructionSection>
    <SecretManagerSection>
        <currentId>0</currentId>
        <tokenSequenceNumber>0</tokenSequenceNumber>
        <numDelegationKeys>0</numDelegationKeys>
        <numTokens>0</numTokens>
    </SecretManagerSection>
    <CacheManagerSection>
        <nextDirectiveId>1</nextDirectiveId>
        <numDirectives>0</numDirectives>
        <numPools>0</numPools>
    </CacheManagerSection>
</fsimage>

问题：Fsimage中为什么没有记录块所对应DataNode？

在内存元数据中是有记录块所对应的dn信息，但是fsimage中就剔除了这个信息；HDFS集群在启动的
时候会加载image以及edits文件，block对应的dn信息都没有记录，集群启动时会有一个安全模式
（safemode）,安全模式就是为了让dn汇报自己当前所持有的block信息给nn来补全元数据。后续每隔
一段时间dn都要汇报自己持有的block信息。

6.2.2 Edits文件内容

基本语法

hdfs oev -p 文件类型 -i编辑日志 -o 转换后文件输出路径

案例实操

[root@linux121 current]# hdfs oev -p XML -i edits_0000000000000000194-0000000000000000195 -o /opt/lagou/servers/hadoop-2.9.2/edits.xml
[root@linux121 current]# cat /opt/lagou/servers/hadoop-2.9.2/edits.xml

备注：Edits中只记录了更新相关的操作，查询或者下载文件并不会记录在内！！

问题：NameNode启动时如何确定加载哪些Edits文件呢？

nn启动时需要加载fsimage文件以及那些没有被2nn进行合并的edits文件，nn如何判断哪些edits已经
被合并了呢？

可以通过fsimage文件自身的编号来确定哪些已经被合并。

6.3 checkpoint周期

vim hadoop-2.9.2/etc/hadoop/hdfs-site.xml 在该文件中配置以下信息：

<!-- 定时一小时 -->
<property>
	<name>dfs.namenode.checkpoint.period</name>
	<value>3600</value>
</property>

<!-- 一分钟检查一次操作次数，当操作次数达到1百万时，SecondaryNameNode执行一次 -->
<property>
	<name>dfs.namenode.checkpoint.txns</name>
	<value>1000000</value>
	<description>操作动作次数</description>
</property>

<property>
	<name>dfs.namenode.checkpoint.check.period</name>
	<value>60</value>
	<description> 1分钟检查一次操作次数</description>
</property >

7 NN故障处理

NameNode故障后，HDFS集群就无法正常工作，因为HDFS文件系统的元数据需要由NameNode来管理维护并与Client交互，如果元数据出现损坏和丢失同样会导致NameNode无法正常工作进而HDFS文件系统无法正常对外提供服务。

如果元数据出现丢失损坏如何恢复呢？

将2NN的元数据拷贝到NN的节点下，但此种方式会存在元数据的丢失。
搭建HDFS的HA（高可用）集群，解决NN的单点故障问题！！（借助Zookeeper实现HA，一个Active的NameNode，一个是Standby的NameNode）

8 Hadoop的限额与归档以及集群安全模式

高级命令

HDFS文件限额配置

HDFS文件的限额配置允许我们以文件大小或者文件个数来限制我们在某个目录下上传的文件数量
或者文件内容总量，以便达到我们类似百度网盘网盘等限制每个用户允许上传的最大的文件的量。

数量限额

hdfs dfs -mkdir -p /user/root/lagou #创建hdfs文件夹
hdfs dfsadmin -setQuota 2 /user/root/lagou #给该文件夹下面设置最多上传两个文件，上传文件，发现只能上传一个文件
hdfs dfsadmin -clrQuota /user/root/lagou #清除文件数量限制

空间大小限额

hdfs dfsadmin -setSpaceQuota 4k /user/root/lagou  #限制空间大小4KB
hdfs dfs -put /export/softwares/xxx.tar.gz /user/root/lagou #上传超过4Kb的文件大小会提示文件超过限额
hdfs dfsadmin -clrSpaceQuota /user/root/lagou  #清除空间限额
hdfs dfs -count -q -h /user/root/lagou #查看hdfs文件限额数量

HDFS的安全模式

安全模式是HDFS所处的一种特殊状态，在这种状态下，文件系统只接受读数据请求，而不接受删除、修改等变更请求。在NameNode主节点启动时，HDFS首先进入安全模式，DataNode在启动的时候会向NameNode汇报可用的block等状态，当整个系统达到安全标准时，HDFS自动离开安全模式。如果HDFS出于安全模式下，则文件block不能进行任何的副本复制操作，因此达到最小的副本数量要求是基于DataNode启动时的状态来判定的，启动时不会再做任何复制（从而达到最小副本数量要求），HDFS集群刚启动的时候，默认30s钟的时间是出于安全期的，只有过了30s之后，集群脱离了安全期，然后才可以对集群进行操作。
```
hdfs dfsadmin  -safemode
```
Hadoop归档技术

主要解决HDFS集群存在大量小文件的问题。

由于大量小文件会占用NameNode的内存，因此对于HDFS来说存储大量小文件造成NameNode内存资源的浪费。

Hadoop存档文件HAR文件，是一个更高效的文件存档工具，HAR文件是由一组文件通过archive工具创建而来，在减少了NameNode的内存使用的同时，可以对文件进行透明的访问，通俗来说就是HAR文件对NameNode来说是一个文件，因此减少了内存的浪费，对于实际操作处理文件依然是一个一个独立的文件。

案例：

启动YARN集群

[root@linux121 hadoop-2.9.2]$ start-yarn.sh

归档文件

把/user/lagou/input目录里面的所有文件归档成一个叫input.har的归档文件，并把归档后文件
存储到/user/lagou/output路径下。
```
[root@linux121 input]# hadoop archive -archiveName input.har -p /user/lagou/input /user/lagou/output
```

查看归档

[root@linux121 input]# hadoop fs -lsr /user/lagou/output/input.har
[root@linux121 input]# hadoop fs -lsr har:///user/lagou/output/input.har

解归档文件

[root@linux121 input]# hadoop fs -cp har:///user/lagou/output/input.har/* /test02
[root@linux121 input]# hadoop fs -ls /test02

9 日志采集综合案例

9.1 需求分析

定时采集已滚动完毕日志文件
将待采集文件上传到临时目录
备份日志文件

9.2 代码实现

新建一个Maven工程：collect_log

pop.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>ClientDemo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!-- hadoop-common ,hadoop-client,hadoop-hdfs-->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.8.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-common -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-client -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-hdfs -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-hdfs</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
</project>

collector.properties

LOGS.DIR=H:/hadoop/learningCode/mapreduce/collect_log/logFIles
LOG.PREFIX=access.log.
LOG.TMP.FOLDER=H:/hadoop/learningCode/mapreduce/collect_log/logFilesTmp
HDFS.TARGET.FOLDER=/collect_log/
BAK.FOLDER=H:/hadoop/learningCode/mapreduce/collect_log/logFilesBak

Constant.java

package com.lagou.common;

public class Constant {
    public static final String LOGS_DIR = "LOGS.DIR";
    public static final String LOG_PREFIX = "LOG.PREFIX";
    public static final String LOG_TMP_FOLDER = "LOG.TMP.FOLDER";
    public static final String HDFS_TARGET_FOLDER = "HDFS.TARGET.FOLDER";
    public static final String BAK_FOLDER = "BAK.FOLDER";
}

PropTool2.java

package com.lagou.singlton;

import com.lagou.collect.LogCollectorTask;

import java.io.IOException;
import java.util.Properties;

public class PropTool2 {
    //volatile关键字是java中禁止指令重排序的关键字，保证有序性和可见性
    private static volatile Properties prop = null;

    //需要处理可能出现的线程安全问题
    public static Properties getProp() throws IOException {
        if (prop == null) {
            synchronized ("lock") {
                if (prop == null) {
                    prop = new Properties();
                    prop.load(LogCollectorTask.class.getClassLoader().getResourceAsStream("collector.properties"));
                }
            }
        }
        return prop;
    }
}

LogCollectorTask.java

package com.lagou.collect;

import com.lagou.singlton.PropTool2;
import com.lagou.common.Constant;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Properties;
import java.util.TimerTask;

public class LogCollectorTask extends TimerTask {
    @Override
    public void run() {
        Properties prop = null;
        try {
            prop = PropTool2.getProp();
        } catch (IOException e) {
            e.printStackTrace();
        }

        //采集的业务逻辑
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); //格式化时间
        String todayStr = sdf.format(new Date()); //把当天时间进行格式化：2021-07-07
        //1.扫描指定目录，找到待上传文件，原始日志目录
        File logsDir = new File(prop.getProperty(Constant.LOGS_DIR)); //根据路径创建一个File实例
        final String log_prefix = prop.getProperty(Constant.LOG_PREFIX); //获取日志文件前缀
        File[] uploadFiles = logsDir.listFiles(new FilenameFilter() { //返回logsDir下的所有 日志文件名
            public boolean accept(File dir, String name) {
                return name.startsWith(log_prefix); //如果符合前缀要求返回true，反之返回false
            }
        });
        //2.把待上传文件转移到临时目录
        File tmpFile = new File(prop.getProperty(Constant.LOG_TMP_FOLDER)); //创建临时目录的 File实例
        if (!tmpFile.exists()) { //判断临时目录是否存在
            tmpFile.mkdirs(); //若临时目录不存在则创建它
        }
        for (File file : uploadFiles) { //遍历所有日志文件
            file.renameTo(new File(tmpFile.getPath() + "/" + file.getName())); //将所有日志文件移动到临时目录下
        }
        //3.使用hdfs api上传日志文件到指定目录
        Configuration conf = new Configuration();
        conf.set("fs.defaultFS", "hdfs://linux121:9000");

        FileSystem fs = null;
        try {
            fs = FileSystem.get(conf);
            //判断hdfs目标路径是否存在，备份目录是否存在
            Path path = new Path(prop.getProperty(Constant.HDFS_TARGET_FOLDER) + todayStr);//给HDFS目录拼接一个日期
            if (!fs.exists(path)) {
                fs.mkdirs(path); //如果拼接后的HDFS路径不存在则创建它： /collect_log/2021-07-07
            }
            File bakFolder = new File(prop.getProperty(Constant.BAK_FOLDER) + todayStr); //在备份目录后面拼接一个日期
            if (!bakFolder.exists()) {
                bakFolder.mkdirs(); //判断拼接后的备份目录是否存在，若不存在则创建它
            }
            File[] files = tmpFile.listFiles(); //获取临时目录下的所有文件路径
            for (File file : files) { //遍历所有临时文件
                //按照日期分门别类存放：上传临时目录下的所有文件
                fs.copyFromLocalFile(
                        new Path(file.getPath()),
                        new Path(prop.getProperty(Constant.HDFS_TARGET_FOLDER) + todayStr + "/" + file.getName())
                );
                //4.将上传后的文件转移到备份目录
                file.renameTo(new File(bakFolder.getPath() + "/" + file.getName()));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

LogCollector.java

package com.lagou.collect;

import java.util.Timer;

public class LogCollector {
    /*
    1.定时采集已滚动完毕的日志文件
    2.将待采集文件上传到临时目录
    3.备份日志文件
     */

    public static void main(String[] args) {
        Timer timer = new Timer(); //获取定时器对象
        //定时采集任务的调度
        //三个参数：TimerTask task, long delay, long period
        //          采集的业务逻辑     延迟时间     周期时间
        timer.schedule(new LogCollectorTask(), 0, 3600 * 1000);
    }
}

执行LogCollector.java,开启日志采集功能：

posted @ 2021-07-28 22:53 咕噜噜~ 阅读(72) 评论(0) 编辑收藏举报

刷新页面返回顶部

咕噜噜~

守正笃实 久久为功