FTP服务搭建

Bertha 。 2023-10-06 16:51 116阅读 0赞

1、检查是否已经安装了vsftp

首先查看系统中是否成功安装了vsftpd，执行下面命令(有内容则安装了ftp)

  1. rpm -qa | grep vsftpd

2、开始安装

  1. yum install vsftpd -y

3、启动FTP服务

  1. systemctl start vsftpd.service

配置

进入cd /etc/vsftpd目录

ftp的配置文件主要有三个，位于/etc/vsftpd/目录下，分别是：

  1. ftpusers 该文件用来指定那些用户不能访问ftp服务器。
  2. user_list 该文件用来指示的默认账户在默认情况下也不能访问ftp
  3. vsftpd.conf vsftpd的主配置文件

ftp配置：vi /etc/vsftpd/vsftpd.conf

  1. #禁止匿名登录FTP服务器
  2. anonymous_enable=NO
  3. #是否允许本地用户登录
  4. local_enable=YES
  5. #是否允许写入
  6. write_enable=YES
  7. #文件夹的默认权限为022
  8. local_umask=022
  9. #进入每个目录是否显示欢迎信息
  10. dirmessage_enable=YES
  11. #上传/下载文件时记录日志
  12. xferlog_enable=YES
  13. #主动模式(PORT)才有效，是否使用20端口传输数据
  14. connect_from_port_20=YES
  15. #使用标准文件日志
  16. xferlog_std_format=YES
  17. #开启ipv4监听，与listen_ipv6不能同时开启
  18. listen=NO
  19. #同时监听IPv4和IPv6的FTP请求
  20. listen_ipv6=YES
  21. #使用pam模块控制
  22. pam_service_name=vsftpd
  23. #控制用户访问，/etc/vsftpd/user_list是一个黑名单
  24. userlist_enable=YES
  25. #控制主机访问，检查/etc/hosts.allow 和/etc/hosts.deny 中的设置，来决定请求连接的主机，是否允许访问该FTP服务器。
  26. tcp_wrappers=YES

默认被动模式
PORT主动模式：pasv_enable=NO
PASV被动模式：pasv_enable=YES

创建ftp用户

这里主要需要创建的用户无法使用普通登录功能或者telnet，只允许使用ftp登录

  1. useradd -s /sbin/nologin -d /home/ftpuser ftpuser

为用户设置密码

  1. passwd ftpuser

530 Login incorrect.：
注释 vi /etc/pam.d/vsftpd 文件里的这一行，#auth required pam_shells.so
这个语句的意思是只有包含shell的用户才能登录，但是我们创建的用户是nologin不允许登陆的

6、防火墙设置

  1. # 方法一：关闭防火墙
  2. systemctl stop firewalld
  4. # 方法二：开放端口
  5. # 提示：防火墙iptables是centos7之前的服务，centos7开始是firewalld服务，开放端口流程请自行百度。另外注意云服务器需要在云平台上设置安全组开放端口
  6. 开启
  7. # iptables -I INPUT -i eth0 -p tcp --dport 20 -j ACCEPT
  8. # iptables  -I OUTPUT -o eth0 -p tcp --sport 20 -j ACCEPT
  9. 保存
  10. # /etc/rc.d/init.d/iptables save
  11. 重启防火墙
  12. # service iptables restart

7、修改selinux，将SELINUX改为disabled

  1. SELINUX=disabled

8、设置开机启动

  1. chkconfig vsftpd on
  2. 或者
  3. systemctl enable vsftpd.service

9、重启FTP服务

  1. systemctl restart vsftpd.service
  3. 其他命令
  5. #开启
  6. service vsftpd start
  7. #停止
  8. service vsftpd stop
  9. #重启
  10. service vsftpd restart

测试代码

  1. package com.transfer.util;
  3. import org.apache.commons.net.ftp.FTPClient;
  4. import org.apache.commons.net.ftp.FTPReply;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  8. import java.io.File;
  9. import java.io.FileInputStream;
  10. import java.io.FileOutputStream;
  11. import java.io.IOException;
  14. /**
  15.  * Ftp工具
  16.  * @date 2019年12月6日 上午8:56:44
  17.  */
  18. public class FtpUtil {
  19.     private static final Logger logger = LoggerFactory.getLogger(FtpUtil.class);
  20.     private FTPClient ftpClient = null;
  22.     public static void main(String[] args) {
  23.         boolean flag;
  24.         String ip = "192.168.111.201";
  25.         int port = 21;
  26.         String username = "ftpuser";
  27.         String password = "123456";
  28.         FtpUtil ftpUtil = new FtpUtil();
  29.         ftpUtil.login(ip, port, username, password);
  31.         //上传文件
  32.         String remotePath = "/a/b/c";
  33.         String fileName = "测试2.txt";
  34.         String localPath = "F:/测试文件.txt";
  35.         //flag= ftpUtil.uploadFile(remotePath, fileName, localPath);
  36.         // System.out.println(flag);
  38.         //下载文件
  39.         remotePath = "/a/b/c";
  40.         fileName = "测试2.txt";
  41.         localPath = "F:/测试文件-下载.txt";
  42.         // flag = ftpUtil.downloadFile(remotePath, fileName, localPath);
  43.         // System.out.println(flag);
  45.         //删除文件
  46.         remotePath = "/a/b/c";
  47.         fileName = "测试2.txt";
  48.         flag = ftpUtil.deleteFile(remotePath, fileName);
  49.         System.out.println(flag);
  51.     }
  53.     /**
  54.      * 登陆
  55.      * @param ip
  56.      * @param port
  57.      * @param username
  58.      * @param password
  59.      * @date 2019年12月6日 上午9:05:11
  60.      */
  61.     public boolean login(String ip, int port, String username, String password) {
  62.         ftpClient = new FTPClient();
  63.         try {
  64.             logger.info("connecting...ftp服务器:" + ip + ":" + port);
  65.             ftpClient.setControlEncoding("UTF-8");// 编码设置必须放在connect前不然不起作用
  66.             ftpClient.setConnectTimeout(30000);//建立 Socket 连接过程中的超时处理,毫秒
  67.             ftpClient.setDefaultTimeout(30000);//传输控制命令的 Socket 的 SoTimeout 的超时处理,毫秒
  68.             ftpClient.setDataTimeout(30000);//传输数据的 Socket 的 SoTimeout 的超时处理,毫秒
  69.             ftpClient.connect(ip, port); // 连接ftp服务器
  70.             ftpClient.login(username, password); // 登录ftp服务器
  71.             ftpClient.setRemoteVerificationEnabled(false);//取消服务器获取自身Ip地址和提交的host进行匹配，否则当不一致时报出以上异常。
  72.             ftpClient.enterLocalPassiveMode();//被动模式,PASV模式。通知服务器打开一个数据端口，客户端将连接到这个端口进行数据传输。
  73.             ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
  74.             ftpClient.setBufferSize(1024);
  75.             int replyCode = ftpClient.getReplyCode(); // 是否成功登录服务器
  76.             if (FTPReply.isPositiveCompletion(replyCode)) {
  77.                 logger.info("连接成功...ftp服务器:" + ip + ":" + port);
  78.                 return true;
  79.             }
  80.             logger.info("连接失败...ftp服务器:" + ip + ":" + port);
  81.         } catch (Exception e) {
  82.             e.printStackTrace();
  83.             logger.error(e.getMessage(), e);
  84.         }
  85.         return false;
  86.     }
  88.     /**
  89.      * 上传文件
  90.      * @param remotePath ftp服务文件路径
  91.      * @param fileName   ftp服务要保存的文件名
  92.      * @param localPath  本地文件绝对路径
  93.      * @return
  94.      */
  95.     public boolean uploadFile(String remotePath, String fileName, String localPath) {
  96.         FileInputStream fis = null;
  97.         boolean flag = false;
  98.         try {
  99.             logger.info("开始上传文件");
  100.             fis = new FileInputStream(localPath);
  101.             createDirecroty(remotePath);//ftp创建目录
  102.             flag = ftpClient.storeFile(fileName, fis);
  103.             ftpClient.logout();
  104.         } catch (Exception e) {
  105.             logger.error("上传文件失败");
  106.             e.printStackTrace();
  107.             logger.error(e.getMessage(), e);
  108.         } finally {
  109.             if (ftpClient.isConnected()) {
  110.                 try {
  111.                     ftpClient.disconnect();
  112.                 } catch (IOException e) {
  113.                     e.printStackTrace();
  114.                 }
  115.             }
  116.             if (fis != null) {
  117.                 try {
  118.                     fis.close();
  119.                 } catch (IOException e) {
  120.                     e.printStackTrace();
  121.                 }
  122.             }
  123.         }
  124.         return flag;
  125.     }
  127.     /**
  128.      * 下载文件
  129.      * @param remotePath ftp服务文件路径
  130.      * @param fileName   ftp服务保存的文件名
  131.      * @param localPath  本地文件绝对路径
  132.      * @return
  133.      */
  134.     public boolean downloadFile(String remotePath, String fileName, String localPath) {
  135.         FileOutputStream fos = null;
  136.         boolean flag = false;
  137.         try {
  138.             logger.info("开始下载文件");
  139.             //由于默认登录后是进入/目录(注意这里的/实际是指：/home/用户名/)
  140.             if (remotePath.charAt(0) == '/') {
  141.                 remotePath = remotePath.substring(1);
  142.             }
  143.             // FTPFile[] ftpFiles = ftpClient.listFiles(remotePath);
  144.             // String[] listNames = ftpClient.listNames(remotePath);
  145.             // 切换FTP目录
  146.             ftpClient.changeWorkingDirectory(remotePath);
  147.             File localFile = new File(localPath);
  148.             if (!localFile.getParentFile().exists()) {
  149.                 localFile.getParentFile().mkdirs();
  150.             }
  151.             fos = new FileOutputStream(localFile);
  152.             //第一个参数： fileName 如果以/开头就是绝对路径，否则是相对路径
  153.             flag = ftpClient.retrieveFile(fileName, fos);
  154.             ftpClient.logout();
  155.         } catch (Exception e) {
  156.             logger.error("下载文件失败");
  157.             e.printStackTrace();
  158.             logger.error(e.getMessage(), e);
  159.         } finally {
  160.             if (ftpClient.isConnected()) {
  161.                 try {
  162.                     ftpClient.disconnect();
  163.                 } catch (IOException e) {
  164.                     e.printStackTrace();
  165.                 }
  166.             }
  167.             if (fos != null) {
  168.                 try {
  169.                     fos.close();
  170.                 } catch (IOException e) {
  171.                     e.printStackTrace();
  172.                 }
  173.             }
  174.         }
  175.         return flag;
  176.     }
  179.     /**
  180.      * ftp创建目录
  181.      * 创建多层目录文件，如果有ftp服务器已存在该文件，则不创建，如果无，则创建
  182.      * @date 2020/9/1 15:42
  183.      */
  184.     public boolean createDirecroty(String remote) {
  185.         try {
  186.             String directory = remote;
  187.             if (!remote.endsWith("/")) {
  188.                 directory = directory + "/";
  189.             }
  190.             // 如果远程目录不存在，则递归创建远程服务器目录
  191.             if (!directory.equals("/") && !ftpClient.changeWorkingDirectory(directory)) {
  192.                 int start = 0, end;
  193.                 if (directory.startsWith("/")) {
  194.                     start = 1;
  195.                 }
  196.                 end = directory.indexOf("/", start);
  197.                 while (true) {
  198.                     String subDirectory = remote.substring(start, end);
  199.                     // 目录不存在就创建
  200.                     if (!ftpClient.changeWorkingDirectory(subDirectory)) {
  201.                         if (ftpClient.makeDirectory(subDirectory)) {
  202.                             ftpClient.changeWorkingDirectory(subDirectory);
  203.                         }
  204.                     }
  205.                     start = end + 1;
  206.                     end = directory.indexOf("/", start);
  207.                     // 检查所有目录是否创建完毕
  208.                     if (end <= start) {
  209.                         break;
  210.                     }
  211.                 }
  212.             }
  213.             return true;
  214.         } catch (Exception e) {
  215.             e.printStackTrace();
  216.         }
  217.         return false;
  218.     }
  221.     /**
  222.      * 删除文件
  223.      * @param remotePath ftp服务文件路径
  224.      * @param fileName   要删除的文件名称
  225.      * @return
  226.      */
  227.     public boolean deleteFile(String remotePath, String fileName) {
  228.         boolean flag = false;
  229.         try {
  230.             logger.info("开始删除文件");
  231.             //由于默认登录后是进入/目录(注意这里的/实际是指：/home/用户名/)
  232.             if (remotePath.charAt(0) == '/') {
  233.                 remotePath = remotePath.substring(1);
  234.             }
  235.             // 切换FTP目录
  236.             ftpClient.changeWorkingDirectory(remotePath);
  237.             int dele = ftpClient.dele(fileName);
  238.             ftpClient.logout();
  239.             if (dele == 250) {
  240.                 flag = true;
  241.             }
  242.         } catch (Exception e) {
  243.             logger.error("删除文件失败");
  244.             e.printStackTrace();
  245.             logger.error(e.getMessage(), e);
  246.         } finally {
  247.             if (ftpClient.isConnected()) {
  248.                 try {
  249.                     ftpClient.disconnect();
  250.                 } catch (IOException e) {
  251.                     e.printStackTrace();
  252.                 }
  253.             }
  254.         }
  255.         return flag;
  256.     }
  259. }

发表评论

表情：
评论列表 （有 0 条评论，116人围观）

还没有评论，来说两句吧...

相关阅读

    相关 FTP服务搭建

    1、检查是否已经安装了vsftp 首先查看系统中是否成功安装了vsftpd，执行下面命令(有内容则安装了ftp) rpm -qa | grep vsftpd

    Bertha 。Bertha 。/ 0 赞/ 117 阅读

    相关 17. 搭建FTP服务端

    熟悉FTP的读者可能会觉得这个太简单了，直接在网上下载软件安装运行就可以了，客户端和服务器都有，但是只能满足一些简单的工作需求。如果我们通过写Python代码搭建FTP服务器和

    - 日理万妓- 日理万妓/ 0 赞/ 292 阅读

    相关 linux中搭建FTP服务

    FTP服务器 文件传输协议（File Transfer Protocol）是用于在网络上进行文件传输的一套标准协议，使用客户/服务器模式。专门用来传输文件的协议 工作原

    冷不防冷不防/ 0 赞/ 418 阅读

    相关 linux搭建FTP服务

    在万维网出现以前，用户使用DOS方式传输文件，最通用的应用程序就是FTP，FTP属于应用层协议，使用TCP端口20和21进行传输 FTP有两种文件传输模式: 二进制模式，...

    红太狼红太狼/ 0 赞/ 795 阅读