精华内容
下载资源
问答
  • 工作地点:南京、上海 高可用系统架构师岗位职责1、熟悉通用高可用平台,从稳定性、功能、性能等方面,搭建和改进高可用系统架构,满足业务系统大规模、高并发、高可用的需求。2、迭代开发,和业务方紧密合作,帮忙...
    545e52e52d93507ab4bc197ca28c0805.png

    工作地点:南京、上海

    高可用系统架构师

    岗位职责

    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自动运维平台的示例代码几乎没有,为了方便自己后期巩固以及有需要的小伙伴,特以记录!!! 此次对接主要为以下两个功能: 文件采集(对...

    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是一款开源软件,使用JAVA开发; – Hadoop可以提供一个分布式基础架构; Hadoop特点: – 高可靠性、高扩展性、高效性、高容错性、低成本 Hadoop常用组件:...

    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            //查看集群状态

     

    展开全文
  • bdp-dataplatform:基于大数据、数据平台、微服务、机器学习、商城、自动化运维、DevOps、容器部署平台、数据平台采集、数据平台存储、数据平台计算、数据平台开发、数据平台应用搭建的大数据解决方案。 数据来源:...
  • 3.1. 9 Cacti监控平台搭建 46 3.1. 10 Nagios监控平台搭建 50 3.1. 11 Kickstart自动化安装平台 56 4. Linux编程篇 60 4.1 Linux Shell编程 60 4.1. 1 Shell编程简介 60 4.1. 2 Shell变量设置 61 4.1. 3 Shell流程...
  •  陶利军,互联网行业高端低调人士,专注于Linux平台下开源产品的研究和推广,运维构架(服务搭建、集群及高可用),网络安全评估,分布式存储等。 编辑推荐:  《决战Nginx系统卷:高性能Web服务器详解与运维》...
  •  陶利军,互联网行业高端低调人士,专注于Linux平台下开源产品的研究和推广,运维构架(服务搭建、集群及高可用),网络安全评估,分布式存储等。 编辑推荐:  《决战Nginx系统卷:高性能Web服务器详解与运维》...
  • 体验平台简介 面向开发者和中小企业打造的一站式、全云端的开发平台...本教程介绍如何在Linux实例上快速搭建一套Java Web开发环境。 场景体验 场景内容选自 阿里云体验实验室 阿里云体验实验室 提供一台配置了CentOS 7.
  • 1概述1.1概述本文详细介绍了在Linux平台安装部署系统的步骤,供运维人员参考。本文的所有范例,建立在以下平台之上:硬件:Intelx86_64平台,64位CPU操作系统:CentOS6.4x86_64SMP64位操作系统JDK:SUNJDK7...
  • 最近在将公司的一款基于java的webgame从windows平台迁移至Linux平台,这套架构用了一个nginx做负载均衡,将不同应用的请求分发至2个tomcat中,第2个跑游戏的tomcat总是无法正常访问,从搭建环境到调试一...
  • Jenkins只是一个平台,真正运作的都是插件。这就是jenkins流行的原因,因为jenkins什么插件都有。Hudson是Jenkins的前身,是基于Java开发的一种持续集成工具,用于监控程序重复的工作,Hudson后来被收购,成为商业版...
  • Jenkins是一个开源软件项目,是基于Java开发的一种持续集成工具,用于监控持续重复的工作,旨在提供一个开放易用的软件平台,使软件的持续集成变成可能。 两者结合起来,就可以实现开发者提交代码到GitLab,Jenkins...
  • 平台提供了数据回流、集群搭建、版本发布、日常运维等算法服务的全生命周期管控能力。DII在线服务框架支持丰富的表结构类型以及强大的多表检索能力,并提供灵活的插件机制,开发者只需专注于算法逻辑的实现,即可以...
  • 点击蓝字关注我们图扑物联科技是一家专注于物联网数据可视化解决方案的公司,致力于帮助企业快速搭建自己的物联网数据可视化监控平台,帮助企业有效降低研发成本和运维成本,缩短产品上市周期。小迈网关以MQTT物联网...
  • 日志,是开发和运维人员定位错误,分析应用使用情况的一种重要手段。开发中最常见的情景就是测试时,一旦程序出现了异常,就立马想到通过查看程序日志来定位问题所在。目前的Java应用主流的日志框架有Log4J和Logback...
  • 上节给整个调用链的体系结构讲述了,按照我的流程可以搭建出来调用链的项目。架构目标基本功能,可扩展性,可配置性,可运维性。识别系统的方式,就是通过唯一性的包名来完成的。就像克隆人一样的基因都是一样的被...
  • 小弟毕业就来到这家公司,发配到外地(南京)搞java开发。前半年还接触到了一些代码开发,简简单单jsp+struts搭建的系统。 到了后一年纯粹就是处理数据,每天除了select 就是update。数据库里的数据一顿组合后跟各...
  • PAGE PAGE 1 Java中级开发工程师的工作内容 Java中级开发工程师需要参与软件产品的需求分析概要设计编码等工作下面是小编为您精心整理的Java中级开发工程师的工作内容 ...产品上线后配合运维团队保障平台的稳定解决相关
  • Jenkins的搭建与使用

    2020-11-01 15:21:55
    1)主流的运维开发平台,兼容所有主流开发环境。 2)插件市场可与海量业内主流开发工具实现集成。 3)Job为配置单位与日志管理,使运维与开发人员能协同工作。 4)权限管理划分不同Job不同角色。 5)强大的负载...
  • 搭建自动化构建

    2018-07-11 20:08:00
    自动化构建我们用Jenkins,它是一个开源软件项目,是基于Java开发的一种持续集成工具,用于监控持续重复的工作,旨在提供一个开放易用的软件平台,使软件的持续集成变成可能。 使用jenkins的好处: 开发人员:...
  • eolinker搭建(Linux版)

    2021-02-24 17:22:05
    Eolinker是一个api管理平台,可满足各行业客户在不同应用环境中对接口管理全生命周期的个性化需求,提供API开发管理、开发团队协作、自动化测试、网关以及监控等服务,帮助企业实现开发运维一体化,提升开发速度并且...
  • Jenkins是一个开源软件项目,是基于Java开发的一种持续集成工具,用于监控持续重复的工作,旨在提供一个开放易用的软件平台,使软件的持续集成变成可能,是自动化运维可持续集成环境。 1.下载Jenkins包 wget ...
  • 在工作中我们经常须要构件一些基于web的项目,例如内部测试平台运维系统等。本篇主要介绍如何使用后端Django+前端Vue.js的技术栈快速地搭建起一套web项目的框架。Django是Python体系下最成熟的web框架之一,由于...
  • 实际项目中为了将java程序部署到服务器上,服务器的环境和开发者在自己的电脑上运行程序是不一样的,开发期间程序的运行一般依赖于IDE上面集成好的环境,只要在软件上面直接运行main方法一般即可验证,然而Linux服务...
  • 云搜索服务 CSS云搜索服务是一个基于Elasticsearch且完全托管的在线分布式搜索...还可以搭建日志分析平台,在运维上进行业务日志分析和监控,在运营上进行流量分析等等。云搜索服务 CSS云搜索服务是一个基于Elasti...
  • 云搜索服务 CSS云搜索服务是一个基于Elasticsearch且完全托管的在线分布式搜索...还可以搭建日志分析平台,在运维上进行业务日志分析和监控,在运营上进行流量分析等等。云搜索服务 CSS云搜索服务是一个基于Elasti...
  • 从淘宝的技术变迁中我们可以见一些端倪,早期电商刚起来的时候,那会儿的互联网还很简单,使用PHP+Mysql+Apache+Linux就可以快速搭建起一套电商系统,但随着电商平台、支付平台的完善,网上购物开始变得简单,越来越...
  • 近十年来,Spring因其提供的依赖注入功能而广受Java开发者的欢迎,因其可以帮助大家开发出松散耦合的系统。简单来说,用户只需要专注于接口所提供的抽象,即可获得具体的实例。如今随着云计算越发流行,如何充分利用...
  • java转大数据方向如何走?

    千次阅读 2019-04-02 23:48:01
    大数据的三个发展方向,平台搭建/优化/运维/监控、大数据开发/ 设计/ 架构、数据分析/挖掘。请不要问我哪个容易,哪个前景好,哪个钱多。 先扯一下大数据的4V特征: 数据量大,TB->PB 数据类型繁多,结构化、...

空空如也

空空如也

1 2 3 4
收藏数 69
精华内容 27
关键字:

java搭建运维平台

java 订阅