一.目标：为基于nginx多web项目搭建sftp服务器，可以让公司内部员工自己部署项目到指定目录（其活动也基于此指定目录）
 
 
 
 
 

  二.条件：
 
 
     1.系统：CentOS 7.x x86_64
 
 
     2.ssh 必须大于v4.8
 
 
     3.web目录结构
 
 
 
 /data
 
 
 
 ├── lost+found
 
 
 
 ├── nginx
 //存放nginx相关配置文件
 
 
 
 │   └── vhosts
 
 
 
 │       └── default.conf
 
 
 
 ├── sftp 
 //存放sftp相关配置文件
 
 
 
 │   └── web_sftp.conf
 
 
 
 └── web 
 //存放web项目
 
 
 
    └── x1.ttp2016.com
 
 
 
        ├── Code
 
 
 
        │   └── index.php
 
       └── info
 
 
 
 
 

  三.需求分析：
 
 
     1、线上服务器对安全要求高些，sftp比ftp更安全
 
 
     2、线上服务器需要对用户需要控制，只能让用户在自己的home目录下活动
 
 
     3、用户只能使用sftp，不能ssh到机器进行操作
 
 
 
 
 
 
 

   过程：
 
 
 
 
  1.查看ssh的版本，需大于4.8版本
 
 
 
 
  
  
<span style="white-space:pre">	</span># ssh -V
 
 
 
 
   
 
 
 
 
  
 
 
 
 
  
  2.创建sftp组，利于添加多用户
 
 
 

  
<span style="line-height: 22.4px;"><span style="white-space: pre;">	</span># groupadd sftp</span>
 
 
 
 
   
 
 
 
 
  3.创建第一个sftp用户ttp2016
 
 
 
 
  
<span style="white-space:pre">	</span># useradd -g sftp -s /bin/false ttp2016
<span style="white-space:pre">	</span># passwd ttp2016<span style="white-space:pre">		</span>//密码为ttp2010
   
  
 
   
 
  
 
  4.sftp组的用户home目录指定到/data/web下（此目录为web服务器目录），先新建一个web目录x1.ttp2016.com,然后指定ttp2016的home为/data/web/x1.ttp2016.com
 
 
 
 
  
<span style="white-space:pre">	</span># mkdir -p /data/web/x1.ttp2016.com
<span style="white-space:pre">	</span># usermod -d /data/web/x1.ttp2016.com ttp2016
 
 
 
 
  
 
 
 
 
 
  5.配置sshd_config
 
 
 
 
  
<span style="white-space:pre">	</span># vi /etc/ssh/sshd_config
<span style="white-space:pre">	</span>//找到这行并注释掉
<span style="white-space:pre">	</span>Subsystemsftpinternal-sftp
  
 
  //添加如下一行
      
 
 
 
 
  
<span style="white-space:pre">	</span>include /data/sftp/web_sftp.conf
 
 
 
 
  
 
 
 
 
 
  //编辑web_sftp.conf文件
 
 
 
 
  
  
<span style="white-space:pre">	</span># vi /data/sftp/web_sftp.conf
 
 
 
 
  //添加如下    
 
 
 
 
  //基于用户组sftp的控制
 
 
 
 
  
<span style="white-space:pre">		</span>Subsystem       sftp    internal-sftp  
    <span style="white-space:pre">		</span>Match Group sftp
    <span style="white-space:pre">		</span>ChrootDirectory /data/web
    <span style="white-space:pre">		</span>ForceCommand    internal-sftp
    <span style="white-space:pre">		</span>AllowTcpForwarding no
    <span style="white-space:pre">		</span>X11Forwarding no
 
 
 
 
  
 
 
 
 
 
  //基于用户ttp2016的控制
 
 
 
 
  
  
<span style="white-space:pre">		</span>Subsystem       sftp    internal-sftp  
    <span style="white-space:pre">		</span>Match User ttp2016
    <span style="white-space:pre">		</span>ChrootDirectory /data/web/x2.ttp2016.com或/data/web/%u
    <span style="white-space:pre">		</span>ForceCommand    internal-sftp
    <span style="white-space:pre">		</span>AllowTcpForwarding no
    <span style="white-space:pre">		</span>X11Forwarding no
 
 
 
 
  
 
 
 
 
 
  具体意思
 
 
 
 
  
 
 
 
 
 
      Subsystem       sftp    internal-sftp  
 
 
 
 
      这行指定使用sftp服务使用系统自带的internal-sftp
 
 
 
 
  
 
 
 
 
 
     Match Group sftp  
 
 
 
 
      这行用来匹配sftp组的用户，如果要匹配多个组，多个组之间用逗号分割
 
 
 
 
  
 
 
 
 
 
  匹配用户
 
 
 
 
      Match User mysftp
 
 
 
 
     这样就可以匹配用户了，多个用户名之间也是用逗号分割，但我们这里按组匹配更灵活和方便
 
 
 
 
  
 
 
 
 
 
      ChrootDirectory /data/web/%u  
 
 
 
 
      用chroot将用户的根目录指定到/data/web/%u，%u代表用户名，这样用户就只能在/data/web/%u下活动
 
 
 
 
  
 
 
 
 
 
      ForceCommand    internal-sftp  
 
 
 
 
      指定sftp命令
 
 
 
 
  
 
 
 
 
 
      AllowTcpForwarding no  
 
 
 
 
      X11Forwarding no  
 
 
 
 
      这两行，如果不希望该用户能使用端口转发的话就加上，否则删掉
 
 
 
 
  
 
 
 
 
 
  
  6.设定Chroot目录访问权限
 
 
 
 
  
<span style="white-space:pre">	</span># chown root:sftp -R -v /data/web/x1.ttp2016.com
    <span style="white-space:pre">	</span># chmod 755 -R -v /data/web/x1.ttp2016.com
 
 
 
 
  
 
 
 
 
  
 
 
 
 
 
  目录的权限设定有两个要点：
 
 
 
 
          1、由ChrootDirectory指定的目录开始一直往上到系统根目录为止的目录拥有者都只能是root
 
 
 
 
          2、由ChrootDirectory指定的目录开始一直往上到系统根目录为止都不可以具有群组写入权限
 
 
 
 
  
 
 
 
 
 
   
  所以遵循以上两个原则
 
 
 
 
          1）我们将/data/web/x1.ttp2016.com的所有者设置为了root，所有组设置为sftp
 
 
 
 
          2）我们将/data/web/x1.ttp2016.com的权限设置为755，所有者root有写入权限，而所有组sftp无写入权限
 
 
 
 
  
 
 
 
 
 
  7.建立sftp用户登录后可写入的目录照上面设置后，在重启sshd服务后，用户mysftp已经可以登录，但使用chroot指定根目录后，根应该是无法写入的，所以要新建一个目录供mysftp上传文件。这个目录所有者为mysftp，所有组为sftp，所有者有写入权限，而所有组无写入权限
 
 
 
 
  
<span style="white-space:pre">	</span># mkdir /data/web/x1.ttp2016.com/Code
        # chown ttp2016:sftp -R -v /data/web/x1.ttp2016.com/Code
        # chmod 755 -R -v /data/web/x1.ttp2016.com/Code
 
 
 
 
  
 
 
 
 
  
 
 
 
 
 
  8.重启sshd服务
 
 
 
 
  
<span style="white-space:pre">	</span># service sshd restart
 
 
 
 
  
 
 
 
 
 
  9.关闭SELINUX
 
 
 
 
  
  
<span style="white-space:pre">	</span># vi /etc/selinux/config
        //修改/etc/selinux/config文件中的SELINUX="" 为 disabled ，然后重启。或者
        # setenforce 0
 
 
 
 
  
 
 
 
 
 
  
 
 
 
 

   至此，ttp2016用户将只能在x2.ttp2016.com里面活动，并且只能操作Code文件夹
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

思路
 
1.首先连接ftp服务器
 
2.连接到服务器之后如何上传文件
 
3.上传后如何获取文件
 
4.文件格式是图片如何展示到客户端浏览器
 
5.服务端代码如何接收客户端的文件以及如何返回响应信息给浏览器
 
 主要jar包依赖文件
 
<dependency>
       <groupId>com.jcraft</groupId>
       <artifactId>jsch</artifactId>
       <version>0.1.54</version>
  </dependency>
         <!-- jsch 所依赖的jar包  -->
 <dependency>
       <groupId>com.jcraft</groupId>
       <artifactId>jzlib</artifactId>
       <version>1.1.1</version>
   </dependency>
 
public class SftpUtils {
 
   private static final Logger log = LoggerFactory.getLogger(SftpUtils.class);
    private static ChannelSftp sftp;
    public static Properties properties = LoadProperties.getProperties("/config/sftp.properties");
    private static Channel channel;
    private static Session sshSession;
 
    /**
      * 登陆SFTP服务器
      * @return
      */
     public static boolean getConnect() throws Exception{
         log.info("进入SFTP====");
         boolean result = false;
         JSch jsch = new JSch();
         //获取sshSession  账号-ip-端口，从properties文件中获取连接ftp服务器的相关信息
         sshSession  =jsch.getSession(properties.getProperty("user"), properties.getProperty("ip"), Integer.parseInt(properties.getProperty("port")));
         //添加密码
         sshSession.setPassword(properties.getProperty("password"));
         Properties sshConfig = new Properties();
         //严格主机密钥检查
         sshConfig.put("StrictHostKeyChecking", "no");
 
        sshSession.setConfig(sshConfig);
         //开启sshSession链接
         sshSession.connect();
         //获取sftp通道
         channel = sshSession.openChannel("sftp");
         //开启
         channel.connect();
         sftp = (ChannelSftp) channel;
         result = true;
         return result;
     }
     
     /**
              * 文件上传
      * @param inputStream 上传的文件输入流
      * @param fileCategory 存储文件目录分类
      * @return
      */
     public static String upload(InputStream inputStream, String fileCategory, String fileName) throws Exception{
         String destinationPath = properties.getProperty("destinationPath")+fileCategory;
         try {
             sftp.cd(destinationPath);
             //获取随机文件名
             fileName  = UUID.randomUUID().toString().replace("-", "") + fileName;
             //文件名是 随机数加文件名的后5位
             sftp.put(inputStream, fileName);
         }finally {
             sftp.disconnect();
         }
         return fileName;
     }
  
     /**
          * 下载文件
     *
     * @param downloadFilePath 下载的文件完整目录
     * @param saveFile     保存在本地的文件路径
     * @return 返回的是文件
     */
     public static File download(String downloadFilePath, String saveFile) {
         FileOutputStream fileOutputStream = null;
         try {
             int i = downloadFilePath.lastIndexOf('/');
             if (i == -1)
                 return null;
             sftp.cd(downloadFilePath.substring(0, i));
             File file = new File(saveFile);
             fileOutputStream = new FileOutputStream(file);
             sftp.get(downloadFilePath.substring(i + 1), fileOutputStream);
             return file;
         } catch (Exception e) {
             log.error(e.getMessage());
             return null;
         }finally {
             sftp.disconnect();
             try {
                 fileOutputStream.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
     
     
     /**
          * 获取ftp服务器    (图片)文件流
      * @param downloadFilePath ftp文件上的文件全路径，包括具体文件名 a/b/c.png
      * @return 返回的是文件流
      */
     public static InputStream download(String downloadFilePath) {
         int i = downloadFilePath.lastIndexOf('/');
         InputStream inputStream = null;
         if (i == -1)
             return null;
         try {
             sftp.cd(downloadFilePath.substring(0, i));
             inputStream = sftp.get(downloadFilePath.substring(i + 1));
         } catch (SftpException e) {
             log.error("获取ftp服务文件流发生异常!");
             e.printStackTrace();
         }
         return inputStream;
     }
     
     /* * 断开SFTP Channel、Session连接
      * @throws Exception
      *
      */
     public static void disconnect() {
         if (SftpUtils.sftp != null) {
             if (sftp.isConnected()) {
                 sftp.disconnect();
                 log.info("sftp is closed already");
             }
         }
         if (SftpUtils.sshSession != null) {
             if (SftpUtils.sshSession.isConnected()) {
                 SftpUtils.sshSession.disconnect();
                 log.info("sshSession is closed already");
             }
         }
     }
     
     /**
      * 文件流转为base64字节码
      * @param in
      * @return
      */
     public static String inputStreamtoBase64(InputStream in) throws Exception{
         byte[] bytes = IOUtils.toByteArray(in);
         String base64str = Base64.getEncoder().encodeToString(bytes);
         return base64str;
     }
 
    /** 删除sftp文件
      * @param directPath 需要删除的文件目录
      * @param fileName 需要删除的文件
      * @return
      **/
     public static void deleteFile(String directPath, String fileName) throws Exception{
         //进入需要删除的文件目录下 
         sftp.cd(directPath);
         sftp.rm(fileName);
     }
     
    
     /**
          * 列出某目录下的文件名
      * @param directory 需要列出的文件目录(sftp服务器目录下的)
      * @return  List<String> 返回的文件名列表
      * @throws Exception
      */
     public static List<String> listFiles(String directory) throws Exception {
         Vector fileList;
         List<String> fileNameList = new ArrayList<String>();
         fileList = sftp.ls(directory);
         Iterator it = fileList.iterator();
         while(it.hasNext())
         {
             String fileName = ((LsEntry)it.next()).getFilename();
             if(".".equals(fileName) || "..".equals(fileName)){
             continue;
             }
             fileNameList.add(fileName);
 
        }
         return fileNameList;
         }
 
总结：上面是一个ftp工具类，包括ftp连接，文件上传，文件下载，ftp服务硬盘目录下的文件查询
 
二,服务端后台代码
 
/**
      * 上传文件
      * @param multipartFile 客户端上传的文件
      * @param request
      * @param response
      * @return
      */
     @PostMapping("uploadFile")
     @ResponseBody
     public String uploadFile(@RequestParam("multipartFile") MultipartFile multipartFile, HttpServletRequest request, HttpServletResponse response) {
         //连接sftp服务
         String fileName = null;
         try {
             SftpUtils.getConnect();
             //上传的文件所属类型 banner, mobile, pc, share四种
             //如果未明确默认存放在ftp服务器的share文件目录下
             String fileCategory = request.getParameter("fileCategory")== null ? "share" : request.getParameter("fileCategory");
             //上传的文件名
             fileName = multipartFile.getOriginalFilename();
             int index = fileName.lastIndexOf(".");
             String nameSuffix = fileName.substring(index, fileName.length());
             //禁止上传.exe文件
             if(".exe".equalsIgnoreCase(nameSuffix)) {
                 return renderResult(Global.FALSE, text("上传的文件格式不支持!")); 
             }
             InputStream inputStream = multipartFile.getInputStream();
             String filePath = SftpUtils.upload(inputStream, fileCategory, fileName);
             SftpUtils.disconnect();
             //需要保存到数据库的文件名称
             fileName = fileCategory+"/"+filePath;
         } catch (Exception e) {
             e.printStackTrace();
             logger.error("文件上传过程中发生异常!");
             return renderResult(Global.FALSE, text("上传失败!"));
         }
             return renderResult(Global.TRUE, text(fileName));
     }
     
     /**
      * 下载文件
      * @param request
      * @param response
      * @return
      */
     @RequestMapping("downLoad")
     @ResponseBody
     public Map<String, String> downLoad(HttpServletRequest request, HttpServletResponse response) {
         Map<String, String> paraMap = new HashMap<String, String>();
         paraMap.put("result", "true");
         paraMap.put("msg", "文件下载成功");
         //获取需要下载的文件名称
         //正式情况下是从表中获取，文件格式,文件名称,存入数据库中
         //测试某文件名称
         String fileName = "share/eae3b1a4a6fe4bb48af11381add03c59textJGY.jpg";
         //判断需要下载的文件是否是图片格式，如果是图片则传Base64格式给浏览器
         String fileType = "jpg";
         String oldName = "JGY.jpg";
         String [] imagesTypes = {"jpg", "JPG", "png", "PNG", "bmp", "BMP", "gif", "GIF"};
         boolean flag = false;
         for (int i = 0; i < imagesTypes.length; i++) {
             if(fileType.equalsIgnoreCase(imagesTypes[i])) {
                 flag = true;
                 break;
             }
         }
         try {
             SftpUtils.getConnect();
         } catch (Exception ftpexp) {
             logger.error("ftp连接时发生异常!");
             ftpexp.printStackTrace();
             paraMap.put("result", "false");
             paraMap.put("msg", "ftp连接时发生异常!");
             return paraMap;
         }
         //获取properties文件中ftp服务器存放的路径
         String direct = SftpUtils.properties.getProperty("destinationPath");
         //获取下载文件的文件流            
         String downloadFilePath = direct+fileName;
         InputStream inputStream = SftpUtils.download(downloadFilePath);
         //图片转为base64
         if(flag) {
             try {
                 //文件流转为base64
                 String base64String = SftpUtils.inputStreamtoBase64(inputStream);
                 paraMap.put("base64", base64String);
             } catch (Exception e) {
                 logger.error("文件下载出现异常!");
                 e.printStackTrace();
                 paraMap.put("result", "false");
                 paraMap.put("msg", "文件下载失败!");
                 return paraMap;
             }
             //非图片文件就直接浏览器下载
         } else {
              String agent = request.getHeader("user-agent");
              try {
                  if(StringUtils.contains(agent, "MSIE")||StringUtils.contains(agent,"Trident")){//IE浏览器
                      oldName = URLEncoder.encode(oldName,"UTF8");
                      System.out.println("IE浏览器");
                  }else if(StringUtils.contains(agent, "Mozilla")) {//google,火狐浏览器
                      oldName = new String(oldName.getBytes(), "ISO8859-1");
                  }else {
                      oldName = URLEncoder.encode(oldName,"UTF8");//其他浏览器
                  }
                  response.reset();//重置 响应头
                  response.setContentType("application/x-download");//告知浏览器下载文件，而不是直接打开，浏览器默认为打开
                  response.addHeader("Content-Disposition" ,"attachment;filename=\"" +oldName+ "\"");//下载文件的名称
                  byte[] b = new byte[1024];
                  int len;
                  while((len = inputStream.read(b)) > 0) {
                      response.getOutputStream().write(b, 0, len);;
                  }
              }catch (Exception e) {
                 e.printStackTrace();
                 paraMap.put("result", "false");
                 paraMap.put("msg", "文件下载失败!");
                 return paraMap;
              }finally {
                  try {
                     response.getOutputStream().close();
                 } catch (IOException e) {
                     logger.error("文件输出流关闭发生异常!");
                     e.printStackTrace();
                 }
                  SftpUtils.disconnect();
             }
         }
         return paraMap;
     }

前言
 
现在我们要在Windows系统上写完项目编译后，发布到linux服务端。
 
1、开发工具IntelliJ IDEA
 2、SFTP传输（IntelliJ IDEA已经集成了sftp）
 
实践
 
下面让我们写一个HelloWorld程序来实践下。
 
一、项目结构与代码
 
1、我的项目目录结构
 
 2、HelloWorld.java源码
 
package com.yfw;

// 导入必需的 java 库
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

// 扩展 HttpServlet 类
public class HelloWorld extends HttpServlet {

    private String message;

    public void init() throws ServletException
    {
        // 执行必需的初始化
        message = "Hello World";
    }

    public void doGet(HttpServletRequest request,
                      HttpServletResponse response)
            throws ServletException, IOException
    {
        // 设置响应内容类型
        response.setContentType("text/html");

        // 实际的逻辑是在这里
        PrintWriter out = response.getWriter();
        out.println("<h1>" + message + "</h1>");
    }

    public void destroy()
    {
        // 什么也不做
    }
}
 
3、index.jsp源码
 
<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2019\8\10 0010
  Time: 14:32
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>测试</title>
  </head>
  <body>
    我是HelloWorld主页
  </body>
</html>

 
4、web.xml源码
 
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <servlet>
        <servlet-name>HelloWorld</servlet-name>
        <servlet-class>com.yfw.HelloWorld</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>HelloWorld</servlet-name>
        <url-pattern>/HelloWorld</url-pattern>
    </servlet-mapping>
</web-app>
 
二、项目配置
 
打开项目设置
 
 配置java编译后的class文件输出路径
 
 设置热部署
 
在 Java Web 开发中， 一般更新了 Java 文件后要手动重启 Tomcat 服务器， 才能生效， 有印象没？我是真的遇到过，当时用的编辑器是eclipse，使用的服务器好像是jboss，浪费不少生命啊， 你如上配置的话， 不论是更新 class 类，css文件，html文件，js文件，还是更新 Spring 配置文件都能做到立马生效，大大提高开发效率。热部署省去了重启tomcat的时间。
 
 
配置sftp
 
1、打开Deployment配置
 
 2、配置sftp，并测试连接是否成功。
 

 3、要同步的目录路径设置
 下面的配置是：
 把本地的C:\Users\Administrator\Desktop\Intellij_Project\out\artifacts\Intellij_Project_war_exploded 目录和服务器的
 /opt/tomcat/webapps/sshtest目录同步。
 
 
编译并同步到服务器
 
1、点击锤子图标，编译项目
 
 2、同步编译后的文件到服务器
 

 选择sshtest进行同步
 
 访问你的服务器（可以看到项目已经同步到了服务器）：
 

 由于采用明文传输用户名和密码，FTP协议是不安全的。在同一机房中只要有一台服务器被攻击者控制，它就可能获取到其它服务器上的FTP密码，从而控制其它的服务器。
 
 当然，很多优秀的FTP服务器都已经支持加密。但如果服务器上已经开了SSH服务，我们完全可以使用SFTP来传输数据，何必要多开一个进程和端口呢？
 
 下面，我就从账户设置、SSH设置、权限设置这三个方面来讲讲如何使用SFTP完全替代FTP。
 
 范例
 
 本文要实现以下功能：
 
 SFTP要管理3个目录：
 
 homepage
 blog
 pay
 权限配置如下：
 
 账户www，可以管理所有的3个目录；
 账户blog，只能管理blog目录；
 账户pay，只能管理pay目录。
 web服务器需求：
 
 账户blog管理的目录是一个博客网站，使用apache服务器。apache服务器的启动账户是apache账户，组为apache组。
 账户blog属于apache组，它上传的文件能够被apache服务器删除。同样的，它也能删除在博客中上传的文件（就是属于apache账户的文件）。
 账户设置
 
 SFTP的账户直接使用Linux操作系统账户，我们可以用useradd命令来创建账户。
 
 首先建立3个要管理的目录：
 
 mkdir /home/sftp/homepage
 mkdir /home/sftp/blog
 mkdir /home/sftp/pay
 创建sftp组和www、blog、pay账号，这3个账号都属于sftp组：
 
 groupadd sftp
 useradd -M -d /home/sftp -G sftp www
 useradd -M -d /home/sftp/blog -G sftp blog
 useradd -M -d /home/sftp/pay -G sftp pay
 
 # 将blog账户也加到apache组
 useradd -M -d /home/sftp/blog -G apache blog
 
 #设置3个账户的密码密码
 passwd www
 passwd blog
 passwd pay
 至此账户设置完毕。
 
 SSH设置
 
 首先要升级OpenSSH的版本。只有4.8p1及以上版本才支持Chroot。
 
 CentOS 5.4的源中的最新版本是4.3，因此需要升级OpenSSH。
 
 指定新的源：
 
 vim /etc/yum.repos.d/test.repo
 #输入如下内容
 [centalt] name=CentALT Packages for Enterprise Linux 5 – $basearch
 baseurl=http://centos.alt.ru/repository/centos/5/$basearch/
 enabled=0
 gpgcheck=0
 # wq保存
 执行升级：
 
 yum –enablerepo=centalt update -y openssh* openssl*
 # 重启服务
 service sshd restart
 # 重看版本
 ssh -V
 # OpenSSH_5.8p1, OpenSSL 0.9.8e-fips-rhel5 01 Jul 2008
 升级成功后，设置sshd_config。通过Chroot限制用户的根目录。
 
 vim /etc/ssh/sshd_config
 #注释原来的Subsystem设置
 Subsystem sftp /usr/libexec/openssh/sftp-server
 #启用internal-sftp
 Subsystem sftp internal-sftp
 #限制www用户的根目录
 Match User www
 ChrootDirectory /home/sftp
 ForceCommand internal-sftp
 #限制blog和pay用户的根目录
 Match Group sftp
 ChrootDirectory %h
 ForceCommand internal-sftp
 完成这一步之后，尝试登录SFTP：
 
 sftp www@abc.com
 #或者
 ssh www@abc.com
 #如果出现下面的错误信息，则可能是目录权限设置错误，继续看下一步
 #Connection to abc.com closed by remote host.
 #Connection closed
 权限设置
 
 要实现Chroot功能，目录权限的设置非常重要。否则无法登录，给出的错误提示也让人摸不着头脑，无从查起。我在这上面浪费了很多时间。
 
 目录权限设置上要遵循2点：
 
 ChrootDirectory设置的目录权限及其所有的上级文件夹权限，属主和属组必须是root；
 ChrootDirectory设置的目录权限及其所有的上级文件夹权限，只有属主能拥有写权限，也就是说权限最大设置只能是755。
 如果不能遵循以上2点，即使是该目录仅属于某个用户，也可能会影响到所有的SFTP用户。
 
 chown root.root /home/sftp /home/sftp/homepage /home/sftp/blog /home/sftp/pay
 chmod 755 /home/sftp /home/sftp/homepage /home/sftp/blog /home/sftp/pay
 由于上面设置了目录的权限是755，因此所有非root用户都无法在目录中写入文件。我们需要在ChrootDirectory指定的目录下建立子目录，重新设置属主和权限。以homepage目录为例：
 
 mkdir /home/sftp/homepage/web
 chown www.sftp /home/sftp/homepage/web
 chmod 775 /home/sftp/homepage/web
 要实现web服务器与blog账户互删文件的权限需求，需要设置umask，让默认创建的文件和目录权限为775即可。将下面的内容写入.bashrc中：
 
 umask 0002
 至此，我们已经实现了所有需要的功能。
 
 —————————–
 umask 0002
 —————————–
 一、团队构建环境，文件读写共享
 项目代码位于/svn/prj下，通过svn up更新代码，调用ant来编译、部署。那么，prj这个目录，对于每个人都是需要可读写的。
 我 们知道，用什么用户登录，新创建的文件宿主，就是当前用户。而默认的文件权限是644（-rw-r–r–），张三从代码仓库中update的文件，或 者编译后生成的class文件，李四是没法删除的。执行ant clear必然不成功，每次都用chmod去修改相应文件，总不是个事，那怎么办呢？
 目标很明确：我们希望，开发团队中，每一个开发人员之间的权限是平等的，谁新建的文件都可以被其他人读写。
 分解出来是两个事情：
 1.目录/svn/prj应该属于开发团队，即一个用户组。这很简单，建立一个组，比如叫dev,使用chown即可
 #gruopadd dev
 #useradd zhangshan
 #useradd lisi
 #useradd zhangsan -G dev -g dev
 #useradd lisi -G dev -g dev
 #chown -R :dev /svn/prj
 这里要特别说明一下，-g和-G是有区别的。-G是大家自然理解的，把一个用户加到一个组或者多个组（逗号分隔）里面去。-g呢，则是
 设置用户的gid。也就是用户登陆后初始group(initial group)。
 使用id zhangsan命令，可以看到，uid=zhangsantest,gid=dev,groups=zhangsan,dev。或者使用groups zhangsan，结果是zhangsan dev
 要注意，创建一个用户，默认会创建一个同名的组，如果不加-g参数，gid就是那个组的id，新建文件，组属也是用户同名组。所以在这里，-g和-G都是缺一不可的。
 2.更改文件创建的默认权限为664（-rw-rw-r–）。
 这里涉及到一个知识，就是umask，umask主要用来控制默认创建文件或目录的权限。可以使用umask命令直接修改。在我们的linux环境中，默认的umask是022。
 umask：设置哪位为1，则哪位就没有权限。放开哪位，哪位有权限。但文件例外，最高到666（默认没有执行权限）。目录则可以到777
 比如设置umask为022，则目录最高可以到755，umask为002，则最高目录可以到775
 解决思路：每个用户登录都会执行一些初始化脚本，可以在脚本中修改用户的umask。
 脚本片段如下：
 USERGROUP=`/usr/bin/id -Gn $USER`
 echo $USERGROUP | grep -q dev
 if [ $? -eq 0 ]; then
 umask 0002
 fi
 意思很简单，这里不赘述。要注意的是，Linux中，应该放在/etc/bashrc里面，而不是/etc/profile中。
 登录shell配置文件执行顺序
 /etc/profile–>/etc/profile.d/*.sh–>~/.bash_profile–>~/.bashrc–>/etc/bashrc
 我们应该把这个设置放在最后执行的文件/etc/bashrc的末尾位置，以防止设置被覆盖（实际上，linux的/etc/bashrc文件开头就有一段类似的umask设置）。
 要说明一点：控制用户对某个目录的默认读写权限，是没有直接支持的。在实际中，暂时也没必要，如果真有特殊需要，可以通过crontab设置监控进程定时进行修改，也很简单，在此不做说明。
 二、普通用户的特权身份
 OK，在第一部分中，我们解决了多人文件共享读写，该运行服务器了。不就是tomcat吗，startup一下。事情没想象那么简单，Tomcat运行过 程中，会写日志文件，一开始，简单的把logs目录组属划分给dev，但后来陆续又遇到一系列不同的权限问题。于是反思一下：与其一点点修改运行 Tomcat涉及的那么多文件权限，不如把自己身份临时换一下？这就是我们要说的sudo。
 sudo命令就是sudoer用来执行root操作的。sudoer配置，通过visudo来编辑。
 visudo实际上就是vi /etc/sudoers的包装版。但用这个命令的最大好处是，它有语法检查。
 %dev ALL =NOPASSWORD: /usr/local/tomcat/bin/startup.sh
 %dev ALL =NOPASSWORD: /usr/local/tomcat/bin/shutdown.sh
 百分号表示组，如果是多个组，用%dev,%dev2
 ALL为所有主机。如果要指定主机，可换成某个ip地址。
 NOPASSWORD表示不需要sudoer输入密码。
 最后为授权执行的命令全路径。
 sudoer的配置还有很多，比如可以设置别名等，请读者自行学习。
 执行：组员只需要在原有命令前面加上sudo 即可。
 如此一来，Tomcat停启问题也解决了。
 补充：sudo命令通配符的设置，如果某个目录下的所有命令都可以给sudoers开放，可以使用xxxx/*.sh，但这样一来，使用者必须使用绝对路径执行。而在当前路径也不能使用./xxx.sh。是何原因，待研究。
 三、sftp用户的umask设置
 似乎万事大吉了。但有一天，发现还是有一些文件没有权限覆盖，为什么呢？后来发现这部分文件，都是使用winscp上传的。
 解决办法：
 vi /etc/ssh/sshd_config文件，找到SubSystem sftp /usr/libexec/openssh/sftp-server这一行，修改为
 SubSystem sftp /usr/libexec/openssh/sftp-server.sh
 然后vi /usr/libexec/openssh/sftp-server.sh
 添加
 umask 0002
 /usr/libexec/openssh/sftp-server
 chmod 755 /usr/libexec/openssh/sftp-server.sh 即可。
 当然，umask 0002这行可以跟上面的策略一致
 变成
 USERGROUP=`/usr/bin/id -Gn $USER`
 echo $USERGROUP | grep -q developers
 if [ $? -eq 0 ]; then
 umask 0002
 fi
 
 四、NFS文件设置问题
 A、B 两台服务器，A为NFS服务器，B为挂载服务器。开发中，发现这个目录老是出现权限问题。但查看组属又没什么问题。甚是奇怪。
 具体事例：
 一 个NFS的源路径，比如是hostA:/share，该目录在hostA上的属于用户组dev,hostB mount了这个目录，看到该目录用户组是一个组号，比如105，其实就是hostA上的dev用户组号。但这个组号，在hostB上并不存在 (hostB上也有一个dev组)，如何让hostB上的用户也能读写该目录？最后，终于发现症结所在：两边的组号不一致，而文件的拥有者和组属，本质是 认id不认name的。修改了哪边，都会让另一边无法写，产生了冲突。
 解决办法：把两边的组号修改为一致。
 1.首先，保证hostB上没有105号的组，如果有，则需要协调一个两边都不产生冲突的组号，可能需要修改两边的组号。
 2.组号确定之后，假设105就行，在hostB上执行：groupmod –g 105 dev。变化可以通过/etc/group查看
 3.重新设置改组涉及到的文件的组属。
 4.属于该组的用户需要重新登录，这样才会生效。
 五、root用户的行为限制
 权限问题中，还有root的滥用。如果使用root来编译部署，root产生的文件，dev用户又无权访问了。也就是说，既然已经划分好了小组构建目录，每个用户都应该是dev组成员才对。root用户应该只在授权或普通用户无法解决的时候，再切换使用。