工作地点：南京、上海 
高可用系统架构师
岗位职责
1、熟悉通用高可用平台，从稳定性、功能、性能等方面，搭建和改进高可用系统架构，满足业务系统大规模、高并发、高可用的需求。
2、迭代开发，和业务方紧密合作，帮忙业务方解决技术问题，用技术推动业务发展。
3、容灾与故障演练、流量调度、限流降级、灰度环境等基础技术体系的设计和开发。
4、高可用技术的产品化升级，让技术具备更好的通用性和复制能力。
任职要求
1、硕士研究生及以上学历，互联网/金融/软件行业3年以上java工作经验。
2、精通linux平台上的Java/GO语言编程，熟悉数据库开发技术，熟悉shell编程，对数据结构、算法设计、系统架构设计等有较为深刻的理解。
3、熟悉系统高可用和稳定性方法策略。
4、精于架构设计、性能优化，有故障处理、监控、限流、降级、预案、容量规划实战经验优先。
5、有宽阔的技术视野，对开源和业界技术有一定了解。
6、良好的沟通能力和团队合作精神，有比较强的推动能力。
AIOps 研发工程师
岗位职责
1、智能运维产品如时序数据异常检测、告警根源分析、运维决策支持等的设计与开发。
2、研究 AIOPS领域的相关算法、论文和前沿技术。
3、参与算法和模型的实现，丰富算法库，提供算法解决方案。
任职要求
1、数学或计算机相关专业，硕士研究生及以上学历， 2 年以上工作经验。
2、掌握 JAVA/c++/Python等至少一种编程语言。
3、熟悉机器学习的常见算法，包括但不限于回归、分类、聚类、关联规则等算法。
4、有机器学习、统计或算法等相关领域的研究成果或智能运维相关产品研发经验者优先。
5、能阅读相关领域的英文论文和文献。
运维平台架构师
岗位职责
1、参与监控运维类软件产品的需求讨论，技术方案确定，架构规划和设计，以及技术研发和产品上线工作；管理系统性能、稳定性、安全性、技术先进性等非功能性指标。
2、全面负责软件产品技术开发过程中前中后台技术难点的攻关，参与核心代码审核与分析。
3、负责对监控运维类系统开发新技术的跟踪与应用；对现有系统进行梳理，寻找优化机会，推动优化方案的执行。
任职要求
1、计算机相关专业，硕士研究生及以上学历，3 年以上工作经验，其中至少包括 2 年以上开发经验， 1 年以上架构设计经验。
2、有大型企业级监控运维类系统的架构规划、架构设计和实施经验。
3、扎实的 Java、 Python、 Go 编程基础，熟悉各种数据结构、算法和设计模式。
4、熟悉 Java主流框架工具，有高并发、分布式网络通信、存储等相关经验；熟悉常用的消息中间件， RPC框架，数据层缓存，性能优化等相关技术；熟悉常用的大数据处理相关技术；熟悉主流的开源监控、自动化运维技术。
5、优秀的口头、书面表达能力和沟通能力，善交流、理解能力强。
高级研发经理(Java)
岗位职责:
1、负责系统模块和流程逻辑的设计和优化；搭建系统开发环境，完成系统框架和核心代码编写。
2、统筹外包开发人员完成其他系统模块的开发工作，能够解决开发中的技术难点，推进开发任务。
3、负责业务梳理，分析和发现系统的优化点，负责推动产品架构优化。
任职要求
1、计算机相关专业，硕士研究生及以上学历，2年以上软件开发经验。
2、熟练掌握Java Web开发和Java后台服务开发，曾有过大型复杂商用系统设计开发经验；有良好的编程习惯，代码质量高。
3、有一定的开发管理经验，包括研发任务分解、需求细化、关键技术路线评估等等。
4、具备任一以下知识背景者优先考虑：
a) 熟练掌握ELK技术栈及其原理；
b) 熟悉常用大数据组件如Kafka、Storm、Hadoop、HBase等；
c) 有监控系统或者自动化运维系统相关开发经验；
d) 有云计算管理平台系统的开发经验，熟悉相关代码，并有部署、应用经验；
e) 有VMWare vCenter、阿里云、AWS、Azure等云产品API开发经验。
5、优秀的口头、书面表达能力和沟通能力，善交流、理解能力强。
简历请按姓名+目标岗位投递到邮箱：sukai@htsc.com

Java对接ansible自动运维化平台
经过大量查阅，网上使用Java对接ansible自动运维化平台的示例代码几乎没有，为了方便自己后期巩固以及有需要的小伙伴，特以记录！！！
此次对接主要为以下两个功能：

文件采集(对文件进行批量操作，包括批量从多台主机中采集共性文件如日志文件)
文件分发(对文件进行批量操作，包括批量从多台主机中分发共性文件如日志文件)

场景说明及ansible yum安装
因ansible没有Windows的安装包，所以为了方便测试，搭建了一套Linux环境进行后续工作。
此次采用yum方式安装，在采用yum方式安装Ansible,首先安装EPEL源。

yum install -y http://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm

查看EPEL源中的Ansible版本

yum info ansible

直接安装此版本，如果有其他要求，请调整源，安装其他ansible版本

yum install -y ansible

安装完成之后，查看ansible版本信息

ansible --version

配置Ansible服务器清单

清单文件/etc/ansible/hosts,在此文件中编写节点主机的对应IP地址和端口

我这里只是做一个演示，其中IP后面可以添加节点真实的SSH的端口，在定义的内容上面有一个[]列表，里面的内容为自定义内容，方面为了操作绑定的节点主机，我习惯称之为分组列表

简单的认证一下，Ping一下添加的主机



成功安装ansible ！！
Java代码实现文件分发
顾名思义，文件分发就是把本机的文件分发到多个主机。这时候就需要 Apache POI(大家可以去导入对应的包)来创建本机的文件了(ansible Host配置文件也通过POI创建)
POI创建文件工具类
package com.tiduyun.cmp.operation.utils;

import com.tiduyun.cmp.common.model.operation.HostInfo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Component;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * @author huyuan@tiduyun.com ansible创建文件
 */
@Slf4j
@Component
public class AnsibleCreateFileUtils {
    private final static String filename = "hosts";

    public static String passWordConnect(List<HostInfo> hostInfo, String hostGroup , String directory) throws IOException{
        /** 在本地新建一个文件夹 里面创建一个文件 向里面写入内容 */


        // 创建文件夹对象 创建文件对象
        File folder = new File(directory);
        // 如果文件夹不存在 就创建一个空的文件夹
        if (!folder.exists()) {
            log.info("创建了文件夹{}" , folder);
            folder.mkdirs();
        }
        File file = new File(directory, filename);
        // 如果文件不存在 就创建一个空的文件
        if (!file.exists()) {
            try {
                log.info("创建了文件{}" , file);
                file.createNewFile();
            } catch (IOException e) {
                log.error("error data{}" , e);
            }
        }
        // 写入数据
        // 创建文件字节输出流
        FileOutputStream fos = new FileOutputStream(file);
        try {
            List<String> list = new ArrayList<>();
            for (HostInfo data : hostInfo) {
                // 开始写
                String string = data.getHost() + " ansible_ssh_pass=" + data.getPasswd() + " ansible_ssh_user="
                    + data.getAccount() + " ansible_ssh_port=" + data.getPort();
                list.add(string);
            }
            String splicingData = StringUtils.join(list, "\n");
            String str = "[" + hostGroup + "]" + "\n" + splicingData;
            byte[] bytes = str.getBytes();
            // 将byte数组中的所有数据全部写入
            fos.write(bytes);
            fos.flush();
            log.info("文件内容{}" , str);
            // 删除文件
            // deleteFile(file);
            // 关闭流

        } catch (IOException e) {
            log.error("error data{}" , e);
            throw e;
        }finally {
            if (fos != null) {
                fos.close();
            }
        }
        return directory;
    }

    public static void deleteFile(File file) {
        if (file.exists()) {// 判断路径是否存在
            if (file.isFile()) {// boolean isFile():测试此抽象路径名表示的文件是否是一个标准文件。
                file.delete();
            } else {// 不是文件，对于文件夹的操作
                    // 保存 路径D:/1/新建文件夹2 下的所有的文件和文件夹到listFiles数组中
                File[] listFiles = file.listFiles();// listFiles方法：返回file路径下所有文件和文件夹的绝对路径
                for (File file2 : listFiles) {
                    /*
                     * 递归作用：由外到内先一层一层删除里面的文件 再从最内层 反过来删除文件夹
                     *    注意：此时的文件夹在上一步的操作之后，里面的文件内容已全部删除
                     *         所以每一层的文件夹都是空的  ==》最后就可以直接删除了
                     */
                    deleteFile(file2);
                }
            }
            file.delete();
        } else {
            log.error("该file路径不存在！！");
        }

    }
}


创建主机组配置文件
注：ansible分为两种连接方式，这里采用的是密钥连接，生成的文件已拼接密钥！！！后续的采集与分发都要用到这个。（如有不懂的小伙伴，可以去查找一下ansible的连接方式）
    @Override
    public void ansibleCreateHost(HostInfo hostInfo, String Key) {
        ParamCheckUtils.notNull(hostInfo, "hostInfo");

        List<HostInfo> HostIp = Arrays.asList(hostInfo);
        for (HostInfo data : HostIp) {
            String ansiblePassWd = data.getPasswd();
            String PassWd = hostInfoService.decode(ansiblePassWd);
            data.setPasswd(PassWd);
        }
        try {
            AnsibleCreateFileUtils.passWordConnect(HostIp, ansibleConfigurationItemVo.getHostGroup(),
                ansibleConfigurationItemVo.getDirectory());
        } catch (IOException e) {
            log.error("Failed to create host configuration{}", e);
        }
    }

实现文件分发
主机配置文件已经配置好，接下来就是执行ansible对应的命令，通过Java拼接ansible命令。

执行命令工具类

package com.tiduyun.cmp.operation.utils;

import lombok.extern.slf4j.Slf4j;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.Charset;

import static cn.hutool.db.DbUtil.close;

/**
 * @author huyuan@tiduyun.com ansible执行命令工具类
 * upload 上传文件
 * createRemoteDirectory  创建远程目录
 */
@Slf4j
public class AnsibleExecuteTheOrderUtils {

    private final static String commandBin = "/bin/sh";

    private final static String commandC = "-c";


    /**
     *  创建远程目录
     */
    public static void createRemoteDirectory(String hostGroup, String remotePath, String directory) throws IOException {
        Runtime run = Runtime.getRuntime();
        String[] cmds = new String[3];
        cmds[0] = commandBin;
        cmds[1] = commandC;
        cmds[2] =
                "ansible " + hostGroup + " -m command -a " + "\"mkdir " + remotePath + "\"" + " -i " + directory + "/hosts";

        // 执行CMD命令
        Process p = run.exec(cmds);
        log.info("ansible远程执行命令为{}", cmds[2]);

        BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream(), Charset.forName("UTF-8")));
        try {
            String lineMes;
            while ((lineMes = br.readLine()) != null)
                log.info(lineMes);// 打印输出信息
            try {
                // 检查命令是否执行失败。
                if (p.waitFor() != 0) {
                    if (p.exitValue() == 1)// 0表示正常结束，1：非正常结束
                        log.error("命令执行失败");
                }
            } catch (InterruptedException e) {
                log.error("error data{}", e);
            }
        } catch (IOException e) {
            log.error("fail to carry out command{}", e);
            throw e;
        } finally {
            if (br != null) {
                br.close();
            }
        }

    }

    /**
     *  文件分发
     */
    public static void upload(String hostGroup, String localPath, String remotePath, String directory)
        throws IOException {
        Runtime run = Runtime.getRuntime();
        String[] cmds = new String[3];
        cmds[0] = commandBin;
        cmds[1] = commandC;
        cmds[2] = "ansible " + hostGroup + " -m copy -a " + "\"src=" + localPath + " dest=" + remotePath + "\"" + " -i "
            + directory + "/hosts";
        // 执行CMD命令
        Process p = run.exec(cmds);
        log.info("ansible命令为{}", cmds[2]);

        BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream(), Charset.forName("UTF-8")));
        try {
            String lineMes;
            while ((lineMes = br.readLine()) != null)
                log.info("ansible输出信息为 :" + lineMes);// 打印输出信息
            try {
                // 检查命令是否执行失败。
                if (p.waitFor() != 0) {
                    if (p.exitValue() == 1)// 0表示正常结束，1：非正常结束
                        log.error("命令执行失败");
                }
            } catch (InterruptedException e) {
                log.error("error data{}", e);
            }
        } catch (IOException e) {
            log.error("fail to carry out command{}", e);
            throw e;
        } finally {
            if (br != null) {
                br.close();
            }
        }

    }

    /**
     *  文件采集
     */
    public static void fileCollection(String hostGroup, String remotePath, String localPath , String directory) throws IOException {
        Runtime run = Runtime.getRuntime();
        String[] cmds = new String[3];
        cmds[0] = commandBin;
        cmds[1] = commandC;
        cmds[2] = "ansible " + hostGroup + " -m fetch -a " + "\"src=" + remotePath + " dest=" + localPath + " force=yes backup=yes\"" + " -i "
                + directory + "/hosts";

        // 执行CMD命令
        Process p = run.exec(cmds);
        log.info("ansible远程采集文件命令为{}", cmds[2]);

        BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream(), Charset.forName("UTF-8")));
        try {
            String lineMes;
            while ((lineMes = br.readLine()) != null)
                log.info(lineMes);// 打印输出信息
            try {
                // 检查命令是否执行失败。
                if (p.waitFor() != 0) {
                    if (p.exitValue() == 1)// 0表示正常结束，1：非正常结束
                        log.error("命令执行失败");
                }
            } catch (InterruptedException e) {
                log.error("error data{}", e);
            }
        } catch (IOException e) {
            log.error("fail to carry out command{}", e);
            throw e;
        } finally {
            if (br != null) {
                br.close();
            }
        }

    }

    public static void ExecuteTheOrder(String command) throws IOException {
        log.info("start execute cmd {}", command);

        String[] cmd = new String[] {"/bin/bash", "-c", command};
        Runtime run = Runtime.getRuntime();
        Process p = run.exec(cmd); // 执行CMD命令

        BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream(), Charset.forName("UTF-8")));
        try {
            String lineMes;
            while ((lineMes = br.readLine()) != null)
                log.info("输出信息为 {}", lineMes);// 打印输出信息
            try {
                // 检查命令是否执行失败。
                if (p.waitFor() != 0) {
                    if (p.exitValue() == 1)// 0表示正常结束，1：非正常结束
                        log.error("命令执行失败");
                }
            } catch (InterruptedException e) {
                log.error("error data{}", e);
            }

        } catch (IOException e) {
            log.error("fail to carry out command{}", e);
            throw e;
        } finally {
            if (br != null) {
                br.close();
            }
        }
    }

    public static void disconnect() {
        try {
            close();
        } catch (Exception ex) {
            // Ignore because disconnection is quietly
        }
    }

    // public void execute(String command) throws Exception {
    // log.info("start execute cmd {}", command);
    // try (Session session = sshClient.startSession()) {
    // Session.Command exec = session.exec(command);
    //
    // Integer readLineCount = 0;
    // InputStream in = exec.getInputStream();
    // log.info(IOUtils.readFully(in).toString());
    // String errorMessage = IOUtils.readFully(exec.getErrorStream(), LoggerFactory.DEFAULT).toString();
    // log.info(errorMessage);
    // if (exec.getExitStatus() != null && exec.getExitStatus() != 0) {
    // throw new RuntimeException(
    // "exec " + command + " error,error message is " + errorMessage + ",error code " + exec.getExitStatus());
    // }
    // log.info("exec result code {}", exec.getExitStatus());
    //
    // }
    //
    // }
}


接下来就是调用
package com.tiduyun.cmp.operation.service.impl;

import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import com.tiduyun.cmp.common.model.flow.UploadFile;
import com.tiduyun.cmp.common.model.operation.ComponentInfo;
import com.tiduyun.cmp.common.model.operation.HostInfo;
import com.tiduyun.cmp.common.provider.service.ExceptionBuildService;
import com.tiduyun.cmp.operation.constant.OperationExceptionCode;
import com.tiduyun.cmp.operation.constant.StartCmdSeparate;
import com.tiduyun.cmp.operation.model.AnsibleConfigurationItemVo;
import com.tiduyun.cmp.operation.model.vo.FileQueryVo;
import com.tiduyun.cmp.operation.service.AnsibleTaskRecordService;
import com.tiduyun.cmp.operation.service.ComposerDeployService;
import com.tiduyun.cmp.operation.service.HostInfoService;
import com.tiduyun.cmp.operation.service.UploadFileService;
import com.tiduyun.cmp.operation.utils.AnsibleExecuteTheOrderUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@Slf4j
@Service
public class AnsibleDeployServiceImpl implements ComposerDeployService {

    @Value(value = "${cmp.operation.commandHeader:cmd /c}")
    private String commandHeader;

    @Value(value = "${cmp.operation.filePath:/data/cmp/file}")
    private String filePath;

    @Value(value = "${cmp.operation.remoteFilePath:/tmp}")
    private String remoteFilePath;

    @Autowired
    private AnsibleTaskRecordService ansibleTaskRecordService;

    @Autowired
    private AnsibleConfigurationItemVo ansibleConfigurationItemVo;

    @Autowired
    private UploadFileService uploadFileService;

    @Autowired
    private HostInfoService hostInfoService;

    @Autowired
    private ExceptionBuildService exceptionBuildService;

    @Override
    public void deploy(HostInfo hostInfo, ComponentInfo componentInfo, String cpmposerName) {
        ansibleTaskRecordService.ansibleCreateHost(hostInfo, null);

        try {
            String remotePath = StringUtils.join(remoteFilePath, "/", cpmposerName, "-", componentInfo.getName(), "-",
                RandomUtil.randomString(3));
            log.info("remote file path = {}", remotePath);

            List<Integer> fileIds = getFileIds(componentInfo.getFileUrl());
            if (CollectionUtils.isNotEmpty(fileIds)) {
                FileQueryVo uploadFileQueryVo = new FileQueryVo();
                uploadFileQueryVo.setIds(fileIds);
                List<UploadFile> uploadFiles = uploadFileService.query(uploadFileQueryVo);
                for (UploadFile uploadFile : uploadFiles) {
                    String path = StringUtils.join(filePath, uploadFile.getFilePath());
                    File file = new File(path);
                    if (!file.exists()) {
                        log.error("file url is {}", file.getPath());
                        throw exceptionBuildService.buildException(OperationExceptionCode.FILE_NOT_EXIST,
                            new Object[] {uploadFile.getFileName()});
                    }
                    // 创建远程目录
                    AnsibleExecuteTheOrderUtils.createRemoteDirectory(ansibleConfigurationItemVo.getHostGroup(),
                        StringUtils.join(remotePath), ansibleConfigurationItemVo.getDirectory());

                    // 分发文件
                    AnsibleExecuteTheOrderUtils.upload(ansibleConfigurationItemVo.getHostGroup(), path,
                        StringUtils.join(remotePath, "/", uploadFile.getFileName()),
                        ansibleConfigurationItemVo.getDirectory());
                }
            }
            List<String> startCmds = getStartCmds(componentInfo.getStartCmd());
            if (CollectionUtils.isNotEmpty(startCmds)) {
                String cdCmd = StringUtils.join("cd ", remotePath);
                String execCmd = StringUtils.join(startCmds, ";");
                execCmd = StringUtils.join(cdCmd, ";", execCmd);
                log.info("execCmd= " + execCmd);
                // sshClient.execute(execCmd);
                AnsibleExecuteTheOrderUtils.ExecuteTheOrder(execCmd);

            } else {
                log.error("parse startCmd fail {}", componentInfo.getStartCmd());
            }

        } catch (Exception e) {
            log.error("主机[{}]部署[{}]组件失败,主机ID[{}],组件ID[{}]:", hostInfo.getHost(), componentInfo.getName(),
                hostInfo.getId(), componentInfo.getId(), e);
            throw exceptionBuildService.buildException(OperationExceptionCode.EXECUTE_CMD_ERROR,
                new Object[] {e.getMessage()});

        } finally {
            AnsibleExecuteTheOrderUtils.disconnect();
        }

    }

    @Override
    public boolean isSupport(HostInfo hostInfo) {
        return true;
    }

    private List<Integer> getFileIds(String fileIds) {
        List<Integer> ids = new ArrayList<>();
        if (fileIds == null) {
            return null;
        }
        String[] split = StringUtils.split(fileIds, ",");
        for (String s : split) {
            ids.add(Integer.parseInt(s));
        }
        return ids;
    }

    private List<String> getStartCmds(String startCmd) {
        List<String> cmd = new ArrayList<>();
        if (startCmd == null) {
            return cmd;
        }
        String[] split = StrUtil.split(startCmd, StartCmdSeparate.SIGN);
        cmd.addAll(Arrays.asList(split));
        return cmd;

    }

    public static Boolean needCd(String s) {
        String[] splits = StrUtil.split(s, "&&");
        int maxIndex = splits.length - 1;
        String cmd = splits[maxIndex];
        if (StrUtil.startWith(cmd, "cd")) {
            return false;
        } else {
            return true;
        }

    }
}


文件采集
同上，调用两个工具类
@Override
    public void fileCollection(HostInfo hostInfo, String remotePath, String localPath) {
        ansibleCreateHost(hostInfo, null);
        try {
            log.info("remote file path = {}", remotePath);
            log.info("local file path = {}", localPath);

            // 文件采集
            AnsibleExecuteTheOrderUtils.fileCollection(ansibleConfigurationItemVo.getHostGroup(), remotePath,
                localPath , ansibleConfigurationItemVo.getDirectory());
        } catch (Exception e) {
            log.error("主机[{}]文件采集失败,主机ID[{}]:", hostInfo.getHost(), hostInfo.getId(), e);
            throw exceptionBuildService.buildException(OperationExceptionCode.EXECUTE_CMD_ERROR,
                new Object[] {e.getMessage()});

        } finally {
            AnsibleExecuteTheOrderUtils.disconnect();
        }

    }

以上代码如大家有需要，请自行更改！！！

目录

数据运维的概念以及hadoop概念

Hadoop模式:单机,伪分布式,完全分布式和搭建

数据运维的概念以及hadoop概念

运维需要做的工作:收集数据,搭建平台,数据分析,反馈结果



 

大数据能做什么

企业组织利用相关数据分析帮助他们降低成本,提高效率,开发新产品,做出更明智的业务决策等

把数据集合并后进行分析得出的信息和数据关系性,用来察觉商业趋势,判定研究质量,

大规模并行出来数据库,数据挖掘电网,分布式文件系统或数据库,云计算和可扩展的存储系统等

 

大数据的特性:数量,速度,种类,真实性,价值

 

 

hadoop

一种分析和处理海量数据的软件平台,是开源软件,使用java开发,提供一个分布式基础架构,其特点是高效性,高扩展性,高效性,高容错性,低成本.

 

hadoop常用组件(红色是一定需要安装的)

HDFS:hadoop分布式文件系统(核心组件)

MapReduce:分布式计算框架(核心组件)

Yarn:集群资源管理系统(核心组件)

Zookeeper:分布式协助服务

Hbase:分布式列存数据库

Hive:基于Hadoop的数据仓库

Sqoop:数据同步工具

Pig:基于Hadoop的数据流系统

Mahout:数据挖掘算法库

Flume:日志收集工作

 

 



 

HDFS角色及概念

NameNode:Master节点,管理HDFS的名称空间和数据映射信息,配置副本策略,处理所有客户端请求

Secondary NameNode :定期合并fsimage和fsedits,推送给NameNode,紧急情况下,可辅助恢复NameNode.

                                        但是Seconddary NameNode并非NameNode的热备

DataNode:数据存储节点,存储实际数据,汇报存储信息给NameNode

Client:切分文件,访问HDFS,于NameNode交互,获取文件位置信息,与DataNode交互,获取和写入数据

Block:每块缺省128MB大小,每块可以多个副本

 

 

 



数据在客户端就会被分片,之后访问NameNode节点,之后NameNode会通知客户端,存储在哪里,HDFS Client收到了对应的存储信息,将数据存储到DataNode节点上,当成功存储成功之后,写通知NameNode,并把对应的信息写入到fsimage,fsimage记录了对应的存储的地址.fsedits(文件变更日志)

 

 

 

MapReduce角色及概念

JobTracker :master节点只有一个,管理所有作业/任务的监控\错误处理等,将任务分解成一系列任务,并分派给TaskTracker

TaskTracker:slave节点,一般是多台,运行Map Task和Reduce Task,并与JobTracker交互,汇报任务状态.

Map Task:解析每条数据记录,传递给用户编写的map()并执行,将输出结果写入本次磁盘.如果为map-only作业,直接写入HDFS.

Reduce Task:从Map Task的执行结果中,远程读取输入数据,对数据进行排序,将数据按照分组传递给用户编写的Reduce函数执行

 

 



 

Yarn角色及概念

ResourceManager:处理客户端请求,启动/监控ApplicMaster,监控NodeManager,资源[分配与调度

NodeManager:单个节点上的资源管理,处理来自ResourceManager的命令,处理来自ApplicationMaster的命令

Container:对任务运行环境的抽象,封装了CPU,内存等,多维资源以及环境变量,启动命令等任务运维相关的信息资源分配与调度

ApplicationMaster:数据切分,为了应用程序申请资源,并分配给内部任务,任务监控与容错.

Client:用户与Yarn交互的客户端程序,提交应用程序,监控应用程序状态也,杀死应用程序等.

 

 

 



 

 

Hadoop模式:单机,伪分布式,完全分布式和搭建

搭建所用到机器

192.168.1.60 nn01

192.168.1.61 node1

192.168.1.62 node2

192.168.1.63 node3

单机安装:hadoop的单机模式安装很简单,只需要配置好环境变量即可运行,这个模式一般用来学习和测试Hadoop的功能

 

[root@nn01 ~]# ls

Desktop  hadoop-2.7.7.tar.gz

[root@nn01 ~]# tar -xaf hadoop-2.7.7.tar.gz 

[root@nn01 ~]# mv hadoop-2.7.7 /usr/local/hadoop

[root@nn01 ~]# cd /usr/local/hadoop/

[root@nn01 hadoop]# ls

bin  include  libexec      NOTICE.txt  sbin

etc  lib      LICENSE.txt  README.txt  share

[root@nn01 local]# chown -R root.root hadoop

[root@nn01 local]# jps

1169 Jps

[root@nn01 hadoop]# yum -y install java-1.6.0-openjdk

[root@nn01 hadoop]# rpm -ql java-1.6.0-openjdk

/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.161-2.b14.el7.x86_64/jre/

[root@nn01 hadoop]# vim hadoop-env.sh

 25 export JAVA_HOME="/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.161-2.b14.el7.x86_64/jre/"

 33 export HADOOP_CONF_DIR="/usr/local/hadoop/etc/hadoop"

[root@nn01 hadoop]# ./bin/hadoop

Usage: hadoop [--config confdir] [COMMAND | CLASSNAME]

  CLASSNAME            run the class named CLASSNAME

 

小案例分析:统计文件中哪个单词出现的最多--统计词频

[root@nn01 hadoop]# pwd

/usr/local/hadoop

[root@nn01 hadoop]# mkdir zhy

[root@nn01 hadoop]# cp *.txt zhy/

[root@nn01 hadoop]# cd zhy/

[root@nn01 zhy]# ls

LICENSE.txt  NOTICE.txt  README.txt

[root@nn01 hadoop]#./bin/hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-2.7.7.jar wordcount ./zhy ./zhy1

./zhy为要分析的目录信息./zhy1为分析之后的结果存放路径

[root@nn01 hadoop]# cd zhy1

[root@nn01 zhy1]# ls

part-r-00000  _SUCCESS

[root@nn01 zhy1]# cat part-r-00000 

""AS    2

"AS    17

"COPYRIGHTS    1

"Contribution"    2

"Contributor"    2

 

hadoop常使用的一些分析jar包,因为hadoop是使用java开发的,在开发中是开发一些算法打包成jar包,我们在使用的时候可以直接使用打包使用的算法进行数据分析.

 

组建分布式集群:伪分布式是讲所有的机子配置在一台上.

搭建思路:需要在nno1节点上配置/etc/hosts,之后传送到每台节点上,在配置免秘钥登录,使得nno1可以免秘钥登录到其他的集群上.

[root@nn01 zhy]# cat /etc/hosts

# ::1        localhost localhost.localdomain localhost6 localhost6.localdomain6

127.0.0.1    localhost localhost.localdomain localhost4 localhost4.localdomain4

192.168.1.60 nn01

192.168.1.61 node1

192.168.1.62 node2

192.168.1.63 node3

[root@nn01 zhy]# for i in 192.168.1.{61..63}; do

> scp /etc/hosts root@$i:/etc/hosts

> done

 

node1 node2 node3都要安装

[root@node1 ~]#  yum -y install java-1.8.0-openjdk-devel

[root@nn01 zhy]# vim /etc/ssh/ssh_config 

 58 Host *

 59         GSSAPIAuthentication yes

 60         StrictHostKeyChecking no

[root@nn01 zhy]# ssh-keygen 

[root@nn01 zhy]# for i in 192.168.1.{60..63}

> do

> ssh-copy-id $i;

> done

 

[root@nn01 zhy]# cd /usr/local/hadoop/etc/hadoop/

[root@nn01 hadoop]# ls

capacity-scheduler.xml  hadoop-metrics2.properties  httpfs-signature.secret  log4j.properties            ssl-client.xml.example

configuration.xsl       hadoop-metrics.properties   httpfs-site.xml          mapred-env.cmd              ssl-server.xml.example

container-executor.cfg  hadoop-policy.xml           kms-acls.xml             mapred-env.sh               yarn-env.cmd

core-site.xml           hdfs-site.xml               kms-env.sh               mapred-queues.xml.template  yarn-env.sh

hadoop-env.cmd          httpfs-env.sh               kms-log4j.properties     mapred-site.xml.template    yarn-site.xml

hadoop-env.sh           httpfs-log4j.properties     kms-site.xml             slaves 

[root@nn01 hadoop]# vim slaves 

node1

node2

node3

 

HDFS完全分布式系统配置

环境配置文件:hadoop-env.sh

核心配置文件:core-site.xml (扩展标记性语音)

HDFS配置文件:hdfs-site.xml  (扩展标记性语音)

节点配置文件:slaves

 

[root@nn01 ~]# cd /usr/local/hadoop/etc/hadoop/

[root@nn01 hadoop]# vim core-site.xml   ---在配置文件中添加该选项

 19 <configuration>

 20     <property>

 21         <name>fs.defaultFS</name>  ---指定使用什么存储方式

 22         <value>hdfs://nn01:9000</value>   ---分布式的地址

 23     </property>

 24     <property>

 25         <name>hadoop.tmp.dir</name>   ---hadoop所有数据的根目录,这个是对应节点的数据,不是集群中的所有数据,

 26         <value>/var/hadoop</value>    ----需要对此目录文件进行保护

 27     </property>

 28 </configuration>

 

[root@nn01 hadoop]# vim hdfs-site.xml

21 <property>

 22         <name>dfs.namenode.http-address</name>  ----集群中谁是namenode节点.其他的节点会主动汇报数据给该台

 23         <value>nn01:50070</value>   --

 24     </property>

 25     <property>

 26         <name>dfs.namenode.secondary.http-address</name>  ---集群中谁是namenode.secondary节点.其他的节点会主动汇报数据给该台

 27         <value>nn01:50090</value>

 28     </property>

 29     <property>

 30         <name>dfs.replication</name>  ---数据存储几份

 31         <value>2</value>

 32     </property>

 33 </configuration>

[root@nn01 hadoop]# vim slaves 

node1

node2

node3

[root@nn01 hadoop]# vim hadoop-env.sh

 25 export JAVA_HOME="/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.161-2.b14.el7.x86_64/jre/"

 33 export HADOOP_CONF_DIR="/usr/local/hadoop/etc/hadoop"

 

要求所有的阶段的配置和目录要求一模一样的,所有需要将nno1的配置文件传输到其他的节点上,并检查是否同步

[root@nn01 ~]# for i in node{1..3}; do scp -r  /usr/local/hadoop ${i}:/usr/local; done

[root@nn01 ~]# ssh node1 ls /usr/local/hadoop/ |wc -l

12

[root@nn01 ~]# ssh node2 ls /usr/local/hadoop/ |wc -l

12

[root@nn01 ~]# ssh node3 ls /usr/local/hadoop/ |wc -l

12

 

集群的初始化

格式化文件系统

[root@nn01 ~]# mkdir /var/hadoop  ---创建一个空目录,该目录是空白的

[root@nn01 ~]# cd /var/hadoop/

[root@nn01 hadoop]# ls

[root@nn01 hadoop]# cd /usr/local/hadoop/

[root@nn01 hadoop]# ./bin/hdfs namenode -format

 

20/06/19 10:35:25 INFO common.Storage: Storage directory /var/hadoop/dfs/name has been successfully formatted.

20/06/19 10:35:25 INFO namenode.FSImageFormatProtobuf: Saving image file /var/hadoop/dfs/name/current/fsimage.ckpt_0000000000000000000 using no compression

20/06/19 10:35:25 INFO namenode.FSImageFormatProtobuf: Image file /var/hadoop/dfs/name/current/fsimage.ckpt_0000000000000000000 of size 321 bytes saved in 0 seconds.

20/06/19 10:35:25 INFO namenode.NNStorageRetentionManager: Going to retain 1 images with txid >= 0

20/06/19 10:35:25 INFO util.ExitUtil: Exiting with status 0

20/06/19 10:35:25 INFO namenode.NameNode: SHUTDOWN_MSG: 

/************************************************************

SHUTDOWN_MSG: Shutting down NameNode at nn01/192.168.1.60

 

[root@nn01 hadoop]# cd /var/hadoop/

[root@nn01 hadoop]# ls

dfs

[root@nn01 hadoop]# tree .

.

└── dfs

    └── name

        └── current

            ├── fsimage_0000000000000000000

            ├── fsimage_0000000000000000000.md5

            ├── seen_txid

            └── VERSION

3 directories, 4 files

 

[root@nn01 hadoop]# cd /usr/local/hadoop/

[root@nn01 hadoop]# ls

bin  etc  include  lib  libexec  LICENSE.txt  NOTICE.txt  README.txt  sbin  share  zhy  zhy1

一般执行文件都存放在bin下,sbin是管理服务,etc是防配置文件的,log是启动的时候动态生成的,

[root@nn01 hadoop]# ./sbin/start-dfs.sh ---启动集群

Starting namenodes on [nn01]

nn01: Warning: Permanently added 'nn01' (ECDSA) to the list of known hosts.

nn01: starting namenode, logging to /usr/local/hadoop/logs/hadoop-root-namenode-nn01.out

node1: starting datanode, logging to /usr/local/hadoop/logs/hadoop-root-datanode-node1.out

node3: starting datanode, logging to /usr/local/hadoop/logs/hadoop-root-datanode-node3.out

node2: starting datanode, logging to /usr/local/hadoop/logs/hadoop-root-datanode-node2.out

Starting secondary namenodes [nn01]

nn01: starting secondarynamenode, logging to /usr/local/hadoop/logs/hadoop-root-secondarynamenode-nn01.out

验证集群构建成功

[root@nn01 hadoop]# jps

1256 NameNode

1548 Jps

1439 SecondaryNameNode

[root@nn01 hadoop]# ssh node1 jps

1092 Jps

1018 DataNode

[root@nn01 hadoop]# ssh node2 jps

1058 Jps

983 DataNode

[root@nn01 hadoop]# ssh node3 jps

1058 Jps

984 DataNode

[root@nn01 hadoop]# ./bin/hdfs dfsadmin -report

Live datanodes (3):   有三个角色则证明成功

 

如果出现问题,需要多这个目录下去找log的日志文件

[root@nn01 hadoop]# pwd

/usr/local/hadoop

[root@nn01 hadoop]# ls

bin  etc  include  lib  libexec  LICENSE.txt  logs  NOTICE.txt  README.txt  sbin  share  zhy  zhy1

 

Hadoop是什么:

– Hadoop是一种分析和处理海量数据的软件平台;

– Hadoop是一款开源软件,使用JAVA开发;

– Hadoop可以提供一个分布式基础架构;

Hadoop特点:

– 高可靠性、高扩展性、高效性、高容错性、低成本

Hadoop常用组件:(下面三个组件是针对于运维,其他的不在此论述)

• HDFS: Hadoop分布式文件系统(核心组件)

• MapReduce: 分布式计算框架(核心组件)

• Yarn: 集群资源管理系统(核心组件)

HDFS结构:

图像 小部件

HDFS角色及概念:(负责存储)

• 是Hadoop体系中数据存储管理的基础,是一个高度容错的系统,用于在低成本的通用硬件上运行

Client :

         – 切分文件,将文件切分成块,每块大小128MB,不够的也划分128MB空间.且每块都可以有多个副本;

         – 访问HDFS;

         – 与NameNode交互,获取文件位置信息;

         – 与DataNode交互,读取和写入数据.

NameNode:

         – Master节点,管理HDFS的名称空间和数据块映射信息,配置副本策略,处理所有客户端请求.

Secondary NameNode:

         – 定期合并fsimage 和fsedits,推送给NameNode;

         – 紧急情况下,可辅助恢复NameNode;

         但Secondary NameNode并非NameNode的热备.

DataNode:

         – 数据存储节点,存储实际的数据;

         – 汇报存储信息给NameNode.

原理整合:

<Client>切分数据,并不能直接存储数据,需要访问<NameNode>,由<NameNode>来指定数据存储的位置,然后<Client>将数据存储在相应的<DataNode>中,同时<NameNode>会将数据于位置的映射信息存储在<fsimage>中; HDFS修改数据是采用一种类似于打补丁的方式,将修改信息存放在<fsedits>中,<Secondary NameNode>会定时的将<fsimage>和<fsedits>进行合并,达到更新数据的目的.

MapReduce角色及概念(负责分布式计算):

JobTracker:

          – Master节点只有一个;

          – 管理所有作业/任务的监控、错误处理等;

          – 将任务分解成一系列任务,并分派给TaskTracker;

TaskTracker:

          – Slave节点,一般是多台;

          – 运行Map Task和Reduce Task;

          – 并与JobTracker交互,汇报任务状态.

 Map Task:

          – 解析每条数据记录,传递给用户编写的map()并执行,将输出结果写入本地磁盘;

           – 如果为map-only作业,直接写入HDFS.

 Reducer Task:

           – 从Map Task的执行结果中,远程读取输入数据,对数据进行排序,将数据按照分组传递给用户编写的reduce函数执行.

简单来讲就是<JobTracker>负责分派任务,<TaskTracker>负责完成任务,<JobTracker>并不会关心通过什么方式完成,整个hadoop都是通过这种类似一个领导,下面管理多个下属,领导负责分派任务,下属负责完成这种方式完成的.

Yarn角色及概念:(负责集群管理)

Container:

           – 对任务运行行环境的抽象,封装了CPU 、内存等;

           – 多维资源以及环境变量、启动命令等任务运行相关的信息资源分配与调度.

ApplicationMaster:

           – 数据切分;

           – 为应用程序申请资源,并分配给内部任务;

           – 任务监控与容错.

Yarn的核心思想:

将JobTracker和TaskTacker进行分离,它由下面几大构成组件:

           – ResourceManager一个全局的资源管理器;

           – NodeManager每个节点(RM)代理;

           – ApplicationMaster表示每个应用;

           – 每一个ApplicationMaster有多个Container在NodeManager上运行.

Hadoop的部署模式有三种:

           – 单机

           – 伪分布式

           – 完全分布式

 

Hadoop三大核心组件: 分布式文件系统部署(HDFS)

单机模式安装:

– 获取软件:  http://hadoop.apache.org

[root@namenode ~]# tar -xf hadoop-2.7.7.tar.gz             //解压软件包

root@namenode ~]#chown  -R  root.root hadoop-2.7.7          //将文件夹及其子文件属主和属组更改为root

root@namenode ~]#mv  hadoop-2.7.7  /usr/local/hadoop       //重新规划软件路径,且更名

root@namenode ~]#yum list | grep openjdk           //查找需要的openjdk的版本

root@namenode ~]#yum -y install java-1.8.0-openjdk-devel           //安装jps工具

root@namenode ~]#yum -y install java-1.8.0-openjdk          //在安装jps工具的时候,会将其作为依赖包一起安装

root@namenode ~]#vim  /etc/hosts               //声明自己可以解析自己的主机名

192.168.1.70    namenode

root@namenode ~]#  rpm -ql java-1.8.0-openjdk             //查看openjdk的安装路径

root@namenode ~]#vim /usr/local/hadoop/etc/hadoop/hadoop-env.sh       //修改环境变量

export JAVA_HOME="/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.161-2.b14.el7.x86_64/jre"          //填写java的安装路径

export HADOOP_CONF_DIR="/usr/local/hadoop/etc/hadoop"         //hadoop的配置文件路径

Hadoop的单机模式安装很简单,只需配置好环境变量即可运行,这个模式一般用来学习和测试Hadoop的功能

root@namenode ~]# cd /usr/local/hadoop
root@namenode ~]# mkdir input
root@namenode ~]# cp *.txt input/
root@namenode ~]# /user/local/hadoop/bin/hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-2.7.7.jar wordcount  input  output         //hadoop运行java功能计算input中文件的单词数,并将结果输出到output目录下

 

hadoop完全分布式搭建:



首先按照上图创建虚拟机,更改主机名和IP地址,hadoop的部署是只要将一台配置文件写好,将整个hadoop文件拷贝到其他三台机器上即可,然后从namenode上格式化,启动服务即可.

[root@nn01 ~]# tar -xf hadoop-2.7.7.tar.gz             //解压软件包

root@nn01 ~]#chown  -R  root.root hadoop-2.7.7          //将文件夹及其子文件属主和属组更改为root

root@nn01 ~]#mv  hadoop-2.7.7  /usr/local/hadoop       //重新规划软件路径,且更名

root@nn01 ~]#yum list | grep openjdk           //查找需要的openjdk的版本

root@nn01 ~]#yum -y install java-1.8.0-openjdk-devel           //安装jps工具

root@nn01 ~]#yum -y install java-1.8.0-openjdk          //在安装jps工具的时候,会将其作为依赖包一起安装

root@nn01 ~]#java -version               //验证java安装

root@nn01 ~]#vim  /etc/hosts               //声明解析主机名,四台机器都配置

192.168.1.60    nn01

192.168.1.61    node1

192.168.1.62    node2

192.168.1.63     node3

root@nn01 ~]#for i in {61..63};do rsync -av /etc/hosts root@192.168.1.$i:/etc/;done       //利用rsync同步数据

配置SSH信任关系(NameNode):
          – 注意:不能出现要求输入yes的情况,每台机器都要能登录成功,包括本机!!!

root@nn01 ~]#vim  /etc/ssh/ssh_config
StrictHostKeyChecking no                       //发送秘钥后远程连接不再提示输入"yes"

root@nn01 ~]#ssh-keygen -N '' -f /root/.ssh/id_rsa            //创建秘钥

root@nn01 ~]#for i in {61..63};do scp-copy-id root@192.168.1.$i; done      //将公钥发给datanode机器,保证nn01可以无密码远程数据节点

root@nn01 ~]#  rpm -ql java-1.8.0-openjdk             //查看openjdk的安装路径

<一>修改环境变量:

root@nn01 ~]#vim /usr/local/hadoop/etc/hadoop/hadoop-env.sh       //修改环境变量

export JAVA_HOME="/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.161-2.b14.el7.x86_64/jre"          //填写java的安装路径

export HADOOP_CONF_DIR="/usr/local/hadoop/etc/hadoop"         //hadoop的配置文件路径



<二>修改核心配置文件:

root@nn01 ~]#vim /usr/local/hadoop/etc/hadoop/core-site.xml

<configuration>
<property>
<name>fs.defaultFS</name>                     //文件系统配置参数,hdfs就是一个文件系统
<value>hdfs://nn01:9000</value>           
</property>

<property>
<name>hadoop.tmp.dir</name>                 //数据目录配置参宿,数据的存放路径
<value>/var/hadoop</value>
</property>

</configuration>
root@nn01 ~]#mkdir  /var/hadoop           //创建数据存放目录

root@nn01 ~]#vim /usr/local/hadoop/etc/hadoop/hdfs-site.xml

<configuration>
<property>
<name>dfs.namenode.http-address</name>               //声明NameNode的地址和端口
<value>nn01:50070</value>
</property>

<property>
<name>dfs.namenode.secondary.http-address</name>          //声明SecondaryNameNode的地址和端口
<value>nn01:50090</value>
</property>

<property>
<name>dfs.replication</name>                 //文件冗余份数,2代表,源数据一份,备份一份
<value>2</value>
</property>
</configuration>

root@nn01 ~]#vim /usr/local/hadoop/etc/hadoop/slaves            //声明数据节点的主机名

node1

node2

node3

root@nn01 ~]#for i in {71..73};do rsync -avSH etc/hadoop root@192.168.1.$i:/usr/local/hadoop/etc/; done

//同步配置,让所有机器配置相同

root@nn01 ~]#/usr/local/hadoop/bin/hdfs  namenode  -format       //在namenode上执行格式化操作, 最后几行中有success成功字样

root@nn01 ~]#/usr/local/hadoop/sbin/start-dfs.sh             //启动集群

root@nn01 ~]#/usr/local/hadoop/bin/hdfs  dfsadmin  -report      //可以查看节点的状态信息

root@nn01 ~]#jps               //验证NameNode角色

24177 NameNode
24360 SecondaryNameNode
26123 Jps
[root@node1 ~]# jps             //验证DataNode角色

23333 DataNode
23405 Jps

以上验证都正常,则HDFS搭建完成.



Hadoop三大核心组件: 分布式计算框架部署(MapReduce)

root@nn01 ~]#cd  /usr/local/hadoop/etc/hadoop

root@nn01 hadoop]#mv mapred-site.xml.template mapred-site.xml     //直接更改模板就可以

root@nn01 hadoop]#vim  mapred-site.xml 

<configuration>
<property>
<name>mapreduce.framework.name</name>                  //资源管理类
<value>yarn</value>                        //只支持local和yarn两种,单机使用local,集群使用yarn
</property>
</configuration>

Hadoop三大核心组件: 集群资源管理部署(yarn)

root@nn01 ~]#vim /usr/local/hadoop/etc/hadoop/yarn-site.xml            //资源管理

<configuration>
<property>
<name>yarn.resourcemanager.hostname</name>         //resourcemanager地址
<value>nn01</value>                                  //resourcemanager的主机名nn01
</property>

<property>
<name>yarn.nodemanager.aux-services</name>         //nodemanager 使用哪个计算框架
<value>mapreduce_shuffle</value>                             //计算框架的名称
</property>

</configuration>



root@nn01 ~]#/usr/local/hadoop/sbin/start-yarn.sh          //如果修改了,先执行stop-yarn.sh,再start-yarn.sh

验证服务:

root@nn01 ~]#/usr/local/hadoop/bin/yarn node  -list          //出现下面结果,表示yarn部署成功了

Total Nodes:3

         Node-Id         Node-State    Node-Http-Address    Number-of-Running-Containers

    node03:39643            RUNNING          node03:8042                               0

    node02:41329            RUNNING          node02:8042                               0

    node01:35737            RUNNING          node01:8042

Web访问Hadoop:(在浏览器中输入,会出现web页面)

– namenode web页面(nn01)

# http://192.168.1.60:50070/

– secondory namenode web 页面(nn01)

# http://192.168.1.60:50090/

– datanode web 页面(node1,node2,node3)

# http://192.168.1.62:50075/

使用Web访问Hadoop:

– resourcemanager web页面(nn01)

# http://192.168.1.60:8088/



– nodemanager web页面(node1,node2,node3)

# http://192.168.1.62:8042/

HDFS使用:

• HDFS基本命令

root@nn01 ~]# /usr/local/hadoop/bin/hadoop fs -ls  /       //对应shell命令ls  / ,这里的"/",说的是hdfs文件系统的根路径   

/usr/local/hadoop/bin/hadoop fs -mkdir /abc              //有时会提醒在安全模式下,创建不了,我们要关闭它
[root@nn01 ~]# /usr/local/hadoop/bin/hdfs dfsadmin -safemode leave          //关闭安全模式
[root@nn01 ~]# /usr/local/hadoop/bin/hadoop fs -touchz /zhangsan         //在hdfs根下创建文件zhangsan,如果不知道后面有什么选项,可以先回车,会出现选项提示

上传文件:

[root@nn01 ~]# /usr/local/hadoop/bin/hadoop  fs  -put  /root/hadoop-2.7.7.tar.gz  /abc      //将本机root下的一个文件,上传到hdfs

下载文件:

[root@nn01 ~]#/usr/local/hadoop/bin/hadoop fs  -get  /zhangsan       //将hdfs上的文件下载到当前目录下

Hadoop验证:
– 创建文件夹
[root@nn01 ~]#/usr/local/hadoop/bin/hadoop fs -mkdir /input
– 上传要分析的文件
[root@nn01 ~]# /usr/local/hadoop/bin/hadoop fs  -put  *.txt  /input
– 提交分析作业
[root@nn01 ~]# /usr/local/hadoop/bin/Hadoop  jar  share/hadoop/mapreduce/hadoop-mapreduce-examples-2.7.7.jar  wordcount  /input  /output
– 查看结果
[root@nn01 ~]# /usr/local/hadoop/bin/hadoop fs -cat output/*



HDFS增加节点:
           – 启动一个新的系统,设置SSH免密码登录;
           – 在所有节点修改 /etc/hosts,增加新节点的主机信息;
           – 安装java运行环境(java-1.8.0-openjdk-devel);
           – 修改NameNode的slaves文件增加该节点;
           – 拷贝NamNode的/usr/local/hadoop到本机;
           – 在该节点启动DataNode.

[root@node04 ~]#yum -y install java-1.8.0-openjdk-devel

[root@node04 ~]#vim /etc/hosts

192.168.1.70 namenode
192.168.1.71 node01
192.168.1.72 node02
192.168.1.73 node03
192.168.1.74 node04

[root@node04 ~]# /usr/local/hadoop/sbin/hadoop-daemon.sh start datanode           //启动节点

 [root@nn01 ~]#/usr/local/hadoop/bin/hdfs dfsadmin -setBalancerBandwidth 500000000     //新增节点后,NameNode要将数据同步到新节点上,由于数据量一般都比较大,需要提高同步带宽,以字节为单位,500000000是500Mb带宽 

[root@nn01 ~]#/usr/local/hadoop/sbin/start-balancer.sh

[root@nn01 ~]#/usr/local/hadoop/bin/hdfs dfsadmin  -report            //查看集群状态