云计算笔记_云计算是一种商业计算模型,它将计算任务分布在大量计算机组成的资源池上,使各种应-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_61598325/article/details/142357252

云计算与大数据

云计算定义：云计算是一种商业计算模型。它将计算任务分布在大量计算机构成的资源池上，使各种应用系统能够根据需要获取计算力、存储空间和信息服务

大数据定义：海量数据或巨量数据，其规模巨大到无法通过目前主流的计算机系统在合理时间内获取、存储、管理、处理并提炼以帮助使用者决策。

大数据是内容，云计算是平台（机器）处理加工出有用的数据

云计算特点：超大规模、虚拟化、高可靠性、通用性、高可伸缩性、按需服务、及其廉价

云计算按服务类型分三类：SaaS、PaaS、IasS

服务方式还可以分为公有云、混合云、私有云

Google云计算

分布式文件系统GFS

目的：

1）分布式存储（数据被分散存储在多个物理位置的存储设备，大文件被切割成大小相同的若干块存储）

2）并行访问（多个操作或请求同时进行，以提高处理速度和效率）

3）处理服务器失效问题（若出现故障，导致的数据丢失问题——>冗余备份）

4）应对数据不断增长问题（添加服务器）

系统架构：

1）GFS客户端

2）GFS主服务器

3）GFS数据库服务器

GFS客户端的作用：通过Shell命令方式访问GFS，提供客户端编程接口

GFS主服务器的作用：维护所有文件的元数据，定期向块服务器收集其状态

文件和 Chunk 的命名空间。
文件和 Chunk 的对应关系。
每个 Chunk 副本的存放地点

前两种元数据会存放在主服务器本地磁盘上，持久化存储，并定期复制到远程机器备份。块位置不会持久化存储，而是在块服务器加入集群时询问获得。

GFS数据库服务器的作用：存储和管理文件数据块

GFS数据写入过程：

GFS读取数据过程：

MapReduce框架

一个分布式、并行处理的计算框架,该部分需要用户自己编写如何处理数据的程序，分为Map函数与Reduce函数

实现机制：用户编写好程序后，交给主控程序，其决定任务自动分配工作机去处理map与reduce

这里的map就是Java中的双列集合，以键值对形式表示。

使用键值对（key-value pairs）的形式处理数据是MapReduce模型的一个核心特点，主要有以下几个原因：

数据组织：键值对提供了一种自然的方式来组织和访问数据。键（key）可以作为数据的索引，使得数据的查找和处理更加高效。
简化编程模型：MapReduce通过键值对简化了并行处理的复杂性。开发者只需要关注如何将输入数据转换为键值对，以及如何根据键值对输出结果，而不需要处理数据的并行分配和收集。
分布式处理：在分布式环境中，数据需要在多个计算节点之间分割和传输。键值对的形式使得数据可以根据键进行分组和分配，从而实现负载均衡和数据的局部性。
排序和分组：MapReduce框架会自动对Map阶段输出的键值对进行排序和分组，这为Reduce阶段的处理提供了便利。相同的键会被聚集在一起，使得可以对相同键的数据进行批量处理。
容错性：在分布式计算中，节点可能会失败。键值对的形式有助于数据的恢复和重试机制，因为每个键值对可以独立处理，即使某个节点失败，也只影响特定键的数据。
灵活性：键值对的形式提供了灵活性，允许开发者根据需要定义键和值。键可以是任何可比较的数据类型，值可以是任何数据结构，这使得MapReduce可以应用于多种不同的数据处理任务。
优化和扩展性：键值对的形式使得MapReduce框架可以在内部进行优化，例如，通过合并具有相同键的值来减少网络传输，或者通过并行处理不同的键来提高效率。
聚合操作：在Reduce阶段，相同的键会聚集在一起，这使得执行聚合操作（如求和、平均、最大/最小值等）变得简单和高效。
可扩展的数据处理：键值对的形式使得MapReduce可以轻松扩展到处理PB级别的数据集，因为它允许数据在多个节点上进行分割和处理。

在MapReduce框架中，工作机的分配以及数据的排序分组是由框架本身以及与之配合的分布式文件系统（如Hadoop的HDFS）共同完成的。任务是如何被分配和完成的呢？：

作业调度器（Job Scheduler）：
- MapReduce框架中的作业调度器负责分配任务给工作机（Worker Nodes）。它根据集群的资源情况和任务需求，将Map任务和Reduce任务分配给不同的节点执行。
任务跟踪器（Task Tracker）：
- 在Hadoop中，每个工作节点上运行的任务跟踪器负责管理该节点上的Map和Reduce任务的执行。它与作业调度器通信，接收任务分配，并监控任务的执行状态。
数据的分割和分配：
- 在Map阶段之前，输入数据会被分割成多个数据块（Splits），每个数据块会被分配给一个Map任务。分割策略通常基于数据的大小和集群的配置。
分布式文件系统（Distributed File System）：
- 分布式文件系统（如HDFS）负责存储数据块，并确保数据块在多个节点上的复制和容错。它也参与数据的本地化，尽量将任务分配给存储数据块的节点，以减少网络传输。
排序和分组：
- Map任务的输出会暂时存储在本地磁盘上，并被框架自动排序和分组。在Reduce阶段，相同的键（Key）会被发送到同一个Reduce任务中，以便进行聚合操作。
Shuffle和Sort阶段：
- 在Map任务完成和Reduce任务开始之间，有一个称为“Shuffle”的阶段，框架会负责将Map输出的数据通过网络传输到正确的Reduce任务。在这个阶段，数据会根据键进行排序和分组。
Reduce任务：
- Reduce任务接收来自Shuffle阶段排序和分组后的数据，对具有相同键的数据值进行归约操作，如求和、平均、连接等。

BigTable ：大规模分布式数据库，用于存储结构化数据

BigTable按key(row:string, column:string, time:int64) -> value(string)方式排序，方便快速索引。为了实现集群，BigTable以行名范围对数据拆分片存储

1. 整体架构

BigTable的整体架构由三个核心组件构成：

客户端库（Client Library）：提供用户与BigTable系统交互的接口，处理请求转化、结果返回、错误检查和重试逻辑。
主服务器（Master Server）：负责管理所有的子表服务器，维护数据一致性，处理负载均衡和故障恢复。
子表服务器（Tablet Server）：实际存储数据的组件，每个子表服务器负责管理一部分数据，即子表（Tablet）。

2. 数据存储与索引

BigTable的数据模型是一个稀疏的、分布式的、持久化的多维有序映射表。索引由以下三个维度构成：

行键（Row Key）：任意字节串，数据按行键排序存储，支持高效扫描操作。
列键（Column Key）：用于区分同一行中的不同数据字段，组织成列族（Column Family）。
时间戳（Timestamp）：记录数据版本信息，支持多版本并发控制。

3. 数据拆分与存储

BigTable表被分成多个连续的行块，称为子表（Tablet），每个子表都是一个连续的、不可变的、持久化的、有序的数据集合。
子表以SSTable（Sorted String Table）格式存储在Google的文件系统Colossus上，SSTable提供持久、有序且不可变的键值对映射。

三者关系

GFS（Google File System）、MapReduce和BigTable是Google开发的三个相互独立但又紧密结合的系统，它们共同构成了Google处理和存储大数据的核心技术架构。以下是它们之间的关系：

GFS（Google File System）：
- GFS是Google设计的大规模分布式文件系统，用于存储海量数据。它运行在普通的商用机器上，通过软件方法解决系统可靠性问题，以降低存储成本。
- GFS的主要特点是高可靠性、可扩展性和高吞吐量，它通过在多个数据块服务器（Chunk Server）上存储数据块（Chunk）的多个副本来实现数据的冗余和容错。
MapReduce：
- MapReduce是Google开发的一个编程模型，用于大规模数据集的分布式处理。它包括Map和Reduce两个主要步骤，Map步骤负责处理输入数据并生成中间键值对，Reduce步骤则对这些中间结果进行归约处理。
- MapReduce通常与GFS结合使用，GFS提供数据存储，而MapReduce则利用这些数据进行并行计算。MapReduce的输出通常存储回GFS。
BigTable：
- BigTable是Google设计的大规模分布式数据库，用于存储结构化数据。它是建立在GFS和MapReduce之上的，用于处理PB级别的数据，并能够部署在数千台机器上。
- BigTable将数据分割成称为Tablets的小部分，每个Tablet大约100-200MB，由GFS存储。这种分割机制使得BigTable能够实现良好的负载均衡和数据管理。
相互关系：
- GFS为MapReduce和BigTable提供了底层的数据存储服务。MapReduce处理的数据存储在GFS中，而BigTable则直接建立在GFS之上。
- MapReduce可以用于处理存储在GFS中的数据，生成的结果可以存储回GFS，也可以作为BigTable的输入。
- BigTable利用GFS的高可靠性和可扩展性来存储其Tablets，而MapReduce则可以用于处理BigTable中的数据。

总的来说，GFS、MapReduce和BigTable共同构成了Google处理大数据的基础设施，其中GFS提供存储，MapReduce提供数据处理能力，而BigTable则提供结构化数据的存储和管理。

Amazon云计算服务

计算服务：
- Amazon EC2：提供云端虚拟服务器，允许用户按需启动不同类型和大小的计算实例。
- Amazon ECS：容器管理服务，允许用户在云端运行和管理容器化应用程序。
- Amazon EKS：提供Kubernetes服务，使得用户无需运行自己的Kubernetes集群即可在AWS上运行Kubernetes 。
存储服务：
- Amazon S3：提供对象存储服务，适合从任意位置检索任意数量的数据。
- Amazon EBS：提供弹性块存储服务，与EC2实例配合使用，提供持久块存储。
- Amazon S3 Glacier：提供低成本、长期的数据归档解决方案。
数据库服务：
- Amazon RDS：提供在云端设置、运行和扩展关系数据库的服务。
- Amazon DynamoDB：提供托管式的NoSQL数据库服务。
- Amazon Redshift：提供快速、简单、经济实惠的数据仓库服务。
联网和内容分发服务：
- Amazon VPC：提供虚拟私有云服务，允许用户在AWS云中创建隔离的网络环境。
- Amazon CloudFront：提供全球内容分发网络服务。
分析和大数据服务：
- Amazon Athena：提供使用SQL查询Amazon S3中数据的服务。
- Amazon EMR：提供大数据处理服务，支持多种数据处理框架，如Hadoop和Spark。
人工智能和机器学习服务：
- Amazon SageMaker：提供构建、训练和部署机器学习模型的服务。
- Amazon Rekognition：提供图像和视频分析服务，能够识别和提取图像中的对象和场景。
物联网服务：
- AWS IoT：提供设备管理、数据存储、分析和安全服务，支持设备与AWS云之间的通信。
安全性和合规性服务：
- Amazon Cognito：提供用户身份验证和授权服务。
- AWS Key Management Service：提供密钥管理服务，用于加密和解密数据。
开发人员工具：
- AWS CodeCommit：提供源代码管理服务。
- AWS CodeBuild：提供持续集成和持续交付服务。
管理工具：
- Amazon CloudWatch：提供监控服务，可以监控AWS资源和应用程序。
- AWS CloudFormation：提供基础设施即代码服务，允许用户使用模板来管理AWS资源。
企业级服务：
- AWS Outposts：允许用户在本地环境中运行AWS服务。
- AWS App Mesh：提供微服务网络管理服务

Hadoop

Hadoop是一个由Apache基金会开发的开源框架，它允许使用简单的编程模型来分布式地处理大规模数据集。Hadoop的设计目的是从单个服务器扩展到数千台机器，每台机器都提供本地计算和存储。Hadoop的核心是HDFS（Hadoop Distributed File System，Hadoop分布式文件系统）和MapReduce编程模型。

Hadoop集群包括HDFS集群和YRAN集群。因为

HDFS集群包括

① NameNode（nn）：存储文件的元数据，如文件名，文件目录结构，文件属性（生成时间、副本数、文件权限），以及每个文件的块所在的 DataNode 等。
② DataNode（dn）: 在本地文件系统存储文件块数据，以及块数据校验和。
③ Secondary DataNode（2nn）：用来监控 HDFS 状态的辅助后台程序，每隔一段时间获取 HDFS 元数据的快照。

④Jobtracker : 确定提交代码的执行计划,决定处理那些文件,为不同的任务分配节点,监控所有任务的运行

⑤Tasktracker : Jobtracker作为主节点，Tasktracker管理各个任务在每个从节点上的执行情况。每个Tasktracker执行由Jobtracker分配的单项任务，可以生成多个JVM来并行地处理许多map或reduce任务

------->思想类似GFS，上面的nn,dn,2nn角色是部署在不同服务器上的进程

------->NameNode与DataNode是主从架构，Secondary DataNode是辅助角色，NameNode正常时

------->起备份作用，瘫痪时顶替它发货作用。

------->Jobtracker与Tasktracker是主从架构

YRAN集群包括

①ResourceManager 资源管理器：管理集群中所有资源。

②NodeManager节点管理器：在所有节点上运行，启动或监控容器。

③ApplicationMaster ：每个提交到YARN集群的应用程序都有一个对应的ApplicationMaster，ApplicationMaster负责与ResourceManager协商资源、监控作业进度，并向ResourceManager请求更多资源或报告作业完成情况

④Container：Container是对资源抽象和封装的单位，目的是为了让每个应用程序对应的任务完成执行。它表示在集群节点上分配给应用程序的一组资源，包括CPU、内存和网络等。

-------> ResourceManager与NodeManager也是主从架构

-------->YARN把JobTracker的功能拆分成了ResourceManager,ApplicationMaster

-------->由于YRAN集群与HDFS集群都是由不同进程组成，所以二者是逻辑上是分离的，但是物理

-------->上可以相同，即一些进程可以同时部署在同一个服务器上

在YARN（Yet Another Resource Negotiator）框架中，ApplicationMaster（AM）和NodeManager（NM）之间的关系：

资源请求与分配：
- ApplicationMaster负责向ResourceManager请求资源，这些资源以Container的形式表示。一旦ResourceManager批准了资源请求，它会通知相应的NodeManager准备Container。
任务启动：
- 当NodeManager收到ResourceManager的指令，它会为分配给它的Container准备执行环境，并通知ApplicationMaster。
- ApplicationMaster随后会向NodeManager发送启动任务的命令，包括任务的执行命令、环境设置、所需资源等。
任务监控：
- NodeManager负责监控在其节点上运行的任务（Container）。它会定期向ApplicationMaster发送心跳信号，报告任务的状态和进度，包括CPU使用情况、内存使用情况、磁盘I/O和网络I/O等。

Hadoop安装

具体过程网络查询，这里过一下步骤

环境准备：一般在Linux系统环境下运行

①配置SSH免密登录：主从架构中，主机需要远程登录从机，每次登录都需要密码的话，非常麻烦。从机与主机的通信一般RPC（远程过程调用）机制实现，且为了主机安全性所以一般不需要登录主机

----->ssh是一种远程登录协议，除此之外还有其他协议可供选择

在Hadoop集群中，主机和从机之间的通信是双向的，但是否需要从机登录主机取决于具体的操作和集群的配置。

主机到从机的通信：
- 主机（例如ResourceManager或NameNode）需要与从机（例如NodeManager或DataNode）通信，以管理和监控集群的状态。这通常涉及到发送命令、请求资源使用情况、任务调度等。
- 为了实现这种通信，主机可能需要能够SSH到从机，以便执行远程命令和管理任务。这通常通过配置SSH免密登录来实现，使得主机可以无需手动输入密码就能登录到从机。
从机到主机的通信：
- 从机也需要与主机通信，以报告状态、请求任务、上传数据等。这种通信通常是通过RPC（远程过程调用）机制实现的，不需要从机直接登录到主机。
- 然而，在某些情况下，如集群的维护、故障排查或手动执行某些操作时，从机可能需要能够登录到主机。这同样可以通过配置SSH免密登录来实现。
安全性和权限：
- 出于安全考虑，通常建议限制对主机的访问，因为主机上运行着集群的关键服务。因此，除非必要，否则不建议从机频繁登录主机。
- 在实际操作中，可以通过配置SSH的权限和密钥管理来控制哪些从机可以登录主机，以及它们可以执行哪些操作

② jdk安装：下载jdk压缩包，解压在指定的一个文件夹内（自己选），然后在环境变量中配置（给这个jdk的路径起个名，这样在系统任何地方，只需要叫它的名字就可以打开它，不然一般启动一个程序都需要给出路径）

③Hadoop安装：下载Hadoop压缩包，解压在指定的一个文件夹内（自己选）即可。剩下的就是配置文件，需要根据运行模式进行配置

本地运行模式：适合做代码调试工作

不需要修改任何配置文件即可以运行

伪分布模式：在一台电脑中，运行多个进程以模拟其他服务器

主要配置core-site.xml与hdfs-site.xml

core.site.xml中配置文件系统默认名，临时文件位置

hdfs-site.xml中配置副本数量，NameNode元数据存储位置，DataNode数据存储位置

介绍一下core-site.xml中的参数有哪些

<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
    <!-- 指定Hadoop文件系统的默认名称，通常是一个NameNode的URI -->
    <property>
        <!-- name标签中的参数一般是Hadoop预先设定好的，它有自己的意思，配置value就可以了，这些参数根据需要自己配就好，不需要全配-->
        <name>fs.defaultFS</name>        
        <value>hdfs://namenode:8020</value>
        <!-- hdfs表示hdfs文件系统，namenode是主机名，8020是用于HDFS通信的端口号。伪分布运行的话，主机名是localhost，端号自己定。这就是一个url,类似与http://baidu.com-->
    </property>

    <!-- 指定Hadoop用于存储临时文件的目录 -->
    <property>
        <name>hadoop.tmp.dir</name>
        <value>/app/hadoop/tmp</value>
        <description>A base for other temporary directories.</description>
    </property>

    <!-- 设置文件系统的缓冲区大小，影响数据读写效率 -->
    <property>
        <name>io.file.buffer.size</name>
        <value>4096</value>
        <description>The size of buffer for use in sequence files and other I/O.</description>
    </property>

    <!-- 如果启用了Hadoop的高可用性（HA），指定ZooKeeper集群的地址 -->
    <property>
        <name>ha.zookeeper.quorum</name>
        <value>zk1:2181,zk2:2181,zk3:2181</value>
        <description>Comma separated list of zookeepers for high availability setup.</description>
    </property>

    <!-- 定义抽象文件系统的实现类 -->
    <property>
        <name>fs.AbstractFileSystem.hdfs.impl</name>
        <value>org.apache.hadoop.fs.hdfs.Hdfs</value>
        <description>The implementation class of the hdfs abstract filesystem.</description>
    </property>

    <!-- 指定特定文件系统方案的实现类 -->
    <property>
        <name>fs.hdfs.impl</name>
        <value>org.apache.hadoop.hdfs.DistributedFileSystem</value>
        <description>The implementation class of the hdfs filesystem.</description>
    </property>

    <!-- 定义用于RPC通信的socket工厂类 -->
    <property>
        <name>hadoop.rpc.socket.factory.class.default</name>
        <value>org.apache.hadoop.net.StandardSocketFactory</value>
        <description>Default socket factory</description>
    </property>

    <!-- 定义代理用户可以代理的组和主机 -->
    <property>
        <name>hadoop.proxyuser.[username].groups</name>
        <value>*</value>
        <description>Allow any group to be proxied by the user.</description>
    </property>
    <property>
        <name>hadoop.proxyuser.[username].hosts</name>
        <value>*</value>
        <description>Allow any host to be proxied by the user.</description>
    </property>

    <!-- 指定一个脚本文件的路径，用于确定节点的网络拓扑 -->
    <property>
        <name>net.topology.script.file.name</name>
        <value>/etc/hadoop/nettopology.properties</value>
        <description>Script to get the network topology of the cluster.</description>
    </property>

    <!-- 指定集群使用的身份验证方式 -->
    <property>
        <name>hadoop.security.authentication</name>
        <value>kerberos</value>
        <description>Should Hadoop use Kerberos for authentication?</description>
    </property>

    <!-- 指定是否启用Hadoop的授权功能 -->
    <property>
        <name>hadoop.security.authorization</name>
        <value>true</value>
        <description>Is service-level authorization enabled?</description>
    </property>

    <!-- 定义可以访问Hadoop Web UI的静态用户 -->
    <property>
        <name>hadoop.http.staticuser.user</name>
        <value>dr.who</value>
        <description>Static user for httpfs.</description>
    </property>
</configuration>

介绍一下hdfs-site.xml中的参数有哪些

<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
    <!-- 指定HDFS的副本因子，即数据块在集群中的副本数量 -->
    <property>
        <name>dfs.replication</name>
        <value>3</value>
        <description>Default block replication.</description>
    </property>
    
    <!-- 指定NameNode元数据存放位置 -->
    <property>
        <name>dfs.namenode.name.dir</name>
        <value>file:/app/hadoop/hadoop-2.6.4/name</value>
        <description>NameNode存储元数据的位置（FSImage和edits log）</description>
    </property>
    
    <!-- 指定DataNode数据存储地址 -->
    <property>
        <name>dfs.datanode.data.dir</name>
        <value>file:/app/hadoop/hadoop-2.6.4/data</value>
        <description>数据节点存储实际数据的位置</description>
    </property>
    
    <!-- 指定secondary namenode的HTTP地址和端口 -->
    <property>
        <name>dfs.namenode.secondary.http-address</name>
        <value>hadoop1:9000</value>
        <description>SecondaryNameNode的HTTP地址和端口</description>
    </property>
    
    <!-- 启用WebHDFS REST接口 -->
    <property>
        <name>dfs.webhdfs.enabled</name>
        <value>true</value>
        <description>启用WebHDFS REST接口</description>
    </property>
    
    <!-- 配置HDFS的名称服务 -->
    <property>
        <name>dfs.nameservices</name>
        <value>mycluster</value>
        <description>指定HDFS的名称服务ID</description>
    </property>
    
    <!-- 配置名称服务下的活跃和备用名称节点 -->
    <property>
        <name>dfs.ha.namenodes.mycluster</name>
        <value>nn1,nn2</value>
        <description>指定名称服务下的活跃和备用NameNode名称</description>
    </property>
    
    <!-- 配置名称节点nn1的RPC通信地址 -->
    <property>
        <name>dfs.namenode.rpc-address.mycluster.nn1</name>
        <value>namenode-1:9000</value>
        <description>名称节点nn1的RPC通信地址</description>
    </property>
    
    <!-- 配置名称节点nn2的RPC通信地址 -->
    <property>
        <name>dfs.namenode.rpc-address.mycluster.nn2</name>
        <value>namenode-2:9000</value>
        <description>名称节点nn2的RPC通信地址</description>
    </property>
    
    <!-- 配置共享编辑日志的存储位置，用于支持名称节点的高可用性 -->
    <property>
        <name>dfs.namenode.shared.edits.dir</name>
        <value>qjournal://datanode-1:8485;datanode-2:8485;datanode-3:8485/mycluster</value>
        <description>共享编辑日志存储位置，用于HA模式</description>
    </property>
    
    <!-- 启用自动故障转移功能，以提高HDFS的可用性 -->
    <property>
        <name>dfs.ha.automatic-failover.enabled.mycluster</name>
        <value>true</value>
        <description>启用自动故障转移功能</description>
    </property>
    
    <!-- 配置客户端故障转移代理提供者，用于在名称节点故障时自动切换到备用名称节点 -->
    <property>
        <name>dfs.client.failover.proxy.provider.mycluster</name>
        <value>org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider</value>
        <description>客户端故障转移代理提供者</description>
    </property>
    
    <!-- 配置JournalNode的编辑日志存储目录 -->
    <property>
        <name>dfs.journalnode.edits.dir</name>
        <value>/hadoop/hdfs/journalnode</value>
        <description>JournalNode的编辑日志存储目录</description>
    </property>
</configuration>

全分布模式：

需要修改每个客户机的host文件，将主机名与IP对应，便于用主机名访问

一台客户机上的环境搭建好就可以远程复制到其他客户机

再就是配置文件，详细过程网络查询

Hadoop安装包目录

Hadoop Shell操作命令

类似Linux命令

查看HDFS文件系统状态：
- hdfs dfsadmin -report：显示HDFS的报告信息，包括集群的健康状况、NameNode和DataNode的状态等。
查看HDFS的使用情况：
- hdfs dfsadmin -fsstatus：显示HDFS的文件系统状态，包括剩余空间、已用空间等。
创建目录：
- hdfs dfs -mkdir [-p] <path>：创建一个新的目录。-p参数可以用来创建多级目录。
删除目录或文件：
- hdfs dfs -rm [-r] <path>：删除指定的文件或目录。-r参数表示递归删除。
上传文件到HDFS：
- hdfs dfs -put <localsrc> ... <dst>：将本地文件系统上的文件复制到HDFS上。
从HDFS下载文件：
- hdfs dfs -get [-p] <src> ... <localdst>：从HDFS上复制文件到本地文件系统。
查看文件内容：
- hdfs dfs -cat <path>：显示文件的内容。
- hdfs dfs -text <path>：显示文件内容，并且显示每个数据块的开始位置。
查看文件或目录的详细信息：
- hdfs dfs -ls [-h] <path>：列出目录内容，-h参数以人类可读的格式显示文件大小。
复制文件：
- hdfs dfs -cp <src> ... <dst>：复制文件到HDFS上的另一个位置。
移动文件：
- hdfs dfs -mv <src> ... <dst>：移动文件到HDFS上的另一个位置。
更改文件权限：
- hdfs dfs -chmod [-R] <mode> <path>：更改文件或目录的权限。-R参数表示递归更改。
更改文件所有者：
- hdfs dfs -chown [-R] <owner>[<group>] <path>：更改文件或目录的所有者和组。-R参数表示递归更改。
查看帮助信息：
- hdfs dfs -help：显示HDFS命令的帮助信息。

HDFS Java API

是Hadoop提供的一个编程接口，允许Java程序与HDFS进行交互，执行文件系统操作，如文件上传、下载、目录的创建、文件的删除等。以下是HDFS Java API的一些核心概念和常用方法的详解，使用时在Java中导包即可：

核心类和接口

Configuration：
- 该类用于存储Hadoop集群的配置信息，包括文件系统的类型、NameNode的URI等。可以通过Configuration类加载Hadoop的配置文件（如core-site.xml和hdfs-site.xml）。
FileSystem：
- FileSystem是一个抽象类，提供了操作文件系统的基本接口。它是操作HDFS的核心类，通过这个类可以进行文件的创建、删除、复制等操作。
Path：
- 表示文件系统上的一个路径。在HDFS中，所有的文件和目录都通过Path类来表示。
FileStatus：
- 表示文件或目录的状态信息，如文件大小、权限、所有权等。

常用方法

获取FileSystem实例：
```
Configuration conf = new Configuration(); 
conf.set("fs.defaultFS", "hdfs://namenode:8020"); 
FileSystem fs = FileSystem.get(conf);
```
- 这段代码创建了一个Configuration对象，并设置了HDFS的URI，然后通过FileSystem.get(conf)方法获取FileSystem实例。
创建目录：
```
boolean success = fs.mkdirs(new Path("/path/to/directory"));
```
- mkdirs方法用于在HDFS上创建一个新的目录。

上传文件：

fs.copyFromLocalFile(new Path("/local/path/file.txt"), new Path("/path/in/hdfs"));

将本地文件系统上的文件复制到HDFS上。

下载文件：

fs.copyToLocalFile(new Path("/path/in/hdfs"), new Path("/local/path/file.txt"));

将HDFS上的文件复制到本地文件系统。

删除文件或目录：

boolean success = fs.delete(new Path("/path/to/delete"), true); // true表示递归删除

delete方法用于删除HDFS上的文件或目录。

重命名文件或目录：

boolean success = fs.rename(new Path("/path/to/oldname"), new Path("/path/to/newname"));

rename方法用于重命名HDFS上的文件或目录。

列出目录内容：

RemoteIterator<LocatedFileStatus> fileStatusListIterator = fs.listFiles(new Path("/path/to/directory"), true);
while (fileStatusListIterator.hasNext()) {
    LocatedFileStatus fileStatus = fileStatusListIterator.next();
    System.out.println(fileStatus.getPath().getName());
}

listFiles方法用于列出HDFS上目录的内容。

检查文件或目录是否存在：
```
boolean exists = fs.exists(new Path("/path/to/check"));
```
- exists方法用于检查HDFS上的文件或目录是否存在。

获取文件状态：

FileStatus[] fileStatus = fs.listStatus(new Path("/path/to/directory"));
for (FileStatus status : fileStatus) {
    System.out.println(status.getPath().getName());
}

listStatus方法用于获取HDFS上目录中文件或目录的状态信息。

注意事项

在使用HDFS Java API时，需要确保Hadoop环境已经正确配置，包括core-site.xml和hdfs-site.xml文件。
操作完成后，应该调用fs.close()方法关闭FileSystem实例，释放资源。

Hadoop基本数据类型

Hadoop提供了一系列的数据类型，主要用于MapReduce编程模型中键值对的处理。这些数据类型是可序列化的，可以进行网络传输和文件存储，以及进行大小比较等操作。以下是一些Hadoop中常用的数据类型及其详解：

Text：
- 用于存储字符串数据。在Hadoop中，Text实际上就是一个UTF-8格式的字符串。它是org.apache.hadoop.io.Text类的实例。
ByteWritable：
- 用于存储单字节数值。它是org.apache.hadoop.io.ByteWritable类的实例。
DoubleWritable：
- 用于存储双精度浮点数。它是org.apache.hadoop.io.DoubleWritable类的实例。
FloatWritable：
- 用于存储单精度浮点数。它是org.apache.hadoop.io.FloatWritable类的实例。
IntWritable：
- 用于存储整型数值。它是org.apache.hadoop.io.IntWritable类的实例。
LongWritable：
- 用于存储长整型数值。它是org.apache.hadoop.io.LongWritable类的实例。
BooleanWritable：
- 用于存储布尔值。它是org.apache.hadoop.io.BooleanWritable类的实例。
ArrayWritable：
- 用于存储数组。它是org.apache.hadoop.io.ArrayWritable类的实例，可以存储上述任何类型的数组。
MapWritable：
- 用于存储键值对映射。它是org.apache.hadoop.io.MapWritable类的实例，可以存储一个映射，其中的键和值都是Writable类型。
NullWritable：
- 表示一个空的Writable对象。它是org.apache.hadoop.io.NullWritable类的实例，通常用作MapReduce作业中不关心的键或值。
VIntWritable 和 VLongWritable：
- 变长整数和变长长整数。这些类用于存储整数，它们使用可变长度的编码来存储数值，适合于存储较小的整数，因为它们可以有效地节省空间。VIntWritable是org.apache.hadoop.io.VIntWritable类的实例，VLongWritable是org.apache.hadoop.io.VLongWritable类的实例。

import org.apache.hadoop.io.Text;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

public class TextExample {
    public static class MapClass extends Mapper<Object, Text, Text, IntWritable> {
        private final static IntWritable one = new IntWritable(1);
        private Text word = new Text();

        public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
            word.set(value);
            context.write(word, one);
        }
    }

    public static class ReduceClass extends Reducer<Text,IntWritable,Text,IntWritable> {
        public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
            int sum = 0;
            for (IntWritable val : values) {
                sum += val.get();
            }
            context.write(key, new IntWritable(sum));
        }
    }
}

这些数据类型都实现了Writable接口，这意味着它们都可以被写入到DataOutput中（例如文件或网络流），并且可以从DataInput中读取（例如文件或网络流）。Writable接口提供了write和readFields两个方法，分别用于序列化和反序列化

在MapReduce作业中，这些数据类型常用于定义输入和输出的键值对类型，例如Mapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT>和Reducer<KEYIN, VALUEIN, KEYOUT, VALUEOUT>。开发者可以根据需要选择合适的数据类型来处理数据

MapReduce

MapReduce是一种编程模型和处理框架，用于在大规模数据集上进行分布式处理。它由两个主要的组件组成：Map任务和Reduce任务。以下是MapReduce编程模型的详细解释：

1. MapReduce编程模型的组成部分

Map任务：处理输入数据并将其转换为键值对（key-value pairs）的形式。
Reduce任务：从Map任务中接收键值对，并进行汇总或归约操作。

2. MapReduce作业的生命周期

输入分片：
- 输入数据被Hadoop分割成多个分片，每个分片由一个Map任务处理。
Map阶段：
- Map任务读取输入分片，并生成中间键值对。
Shuffle和Sort阶段：
- Map任务输出的键值对被Shuffled（重新分配）和Sorted（排序）。
Reduce阶段：
- Reduce任务读取排序后的键值对，并生成最终结果。

3. MapReduce编程接口

Mapper：
- map()方法：处理输入键值对，并产生中间键值对。
- setup()方法：在map()方法之前执行，用于初始化。
- cleanup()方法：在map()方法之后执行，用于清理。
Reducer：
- reduce()方法：处理中间键值对，并产生最终结果。
- setup()方法：在reduce()方法之前执行，用于初始化。
- cleanup()方法：在reduce()方法之后执行，用于清理。

4. MapReduce编程示例

以下是一个简单的WordCount程序，它计算文本中每个单词出现的次数：

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

public class WordCount {

    public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable> {
        private final static IntWritable one = new IntWritable(1);
        private Text word = new Text();

        public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
            String[] words = value.toString().split("\\s+");
            for (String w : words) {
                word.set(w);
                context.write(word, one);
            }
        }
    }

    public static class IntSumReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
        public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
            int sum = 0;
            for (IntWritable val : values) {
                sum += val.get();
            }
            context.write(key, new IntWritable(sum));
        }
    }

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf, "word count");
        job.setJarByClass(WordCount.class);
        job.setMapperClass(TokenizerMapper.class);
        job.setCombinerClass(IntSumReducer.class);
        job.setReducerClass(IntSumReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}