java实现代码通过“代理”批量操作linux机器_java如何批量执行linux授权命令-CSDN博客

本文链接：https://blog.csdn.net/fdzq0580/article/details/103983560

需求：有大量的linux机器需要进行发布更新以及其他命令操作，而且网段和本地不通，需要通过代理的方式进行，

按以往的方式，只能一个一个手动上去执行命令，或者传文件上去，这样耗费大量的时间。这个时候想到用代码

来实现这种重复操作，

关键技术：session的登录，xhell通道代理的建立。

具体实现步骤

一：建立本地代理

由于不在同一网段，需要用工具建立一个通道（代理），可以选择SecureCRT,xhell,小红帽等工具建立一个能远程到目标服务器的通道（代理，默认端口设置为1080，使用socks进行动态转发）

二：代码实现

博主用的框架是springboot，主要方便jar包的引入

1：关键jar包的引入，pom.xml文件

需要实现Jsch包中的UserInfo,UIKeyboardInteractive接口，用以保存用户信息，以及进行键盘交互式认证并执行命令

<dependency>
<groupId>com.jcraft</groupId>
<artifactId>jsch</artifactId>
<version>0.1.54</version>
</dependency>

方便调试运行，写成测试类，

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

主类全部代码

package com.hg.test;

import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.ChannelShell;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.ProxySOCKS5;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.UserInfo;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.net.SocketTimeoutException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.springframework.util.StringUtils;

@Slf4j
public class Testsshkylin2 extends BaseTest{

private int timeout = 60000;
private ExecutorService ES = Executors.newFixedThreadPool(50);

@Test
public void test() throws IOException {
String con = read("/******");//此处我写成了json，方便读取，这个用户可以自定义，只要能读取就行，里面主要存放用户名，密码，以及个别判断字段
ObjectMapper objectMapper = new ObjectMapper();
JavaType javaType = objectMapper.getTypeFactory().constructParametricType(ArrayList.class, Server.class);
List<Server> list = objectMapper.readValue(con, javaType);//此处，我新建了一个实体类Server，方便参数的读取，
exec(list);
}
public void exec( List<Server> list) throws IOException {
List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>();
list
.stream().filter(server ->!server.isHh())
.forEach(s -> {
tasks.add(buile(s,s.name));
});
long ss = System.currentTimeMillis();
try {
List<Future<Integer>> results = ES.invokeAll(tasks);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info("执行任务消耗了：" + (System.currentTimeMillis() - ss) + "毫秒");

}

private Callable<Integer> buile(Server s,String name){
return () -> {
try {
readRemote(s,name);
} catch (SocketTimeoutException e) {
log.error("{}\t 网络不通", s.ip);
} catch (Exception e) {
String err=e.getLocalizedMessage();
if(err.equalsIgnoreCase("Auth cancel"))
return 1;
log.error("{}\t{}", s.ip, e.getLocalizedMessage());
}
return 1;
};
}

public void readRemote(final Server s,String staname) throws JSchException, IOException, InterruptedException {
String host = s.ip;
String username = s.user;
String pass = s.pass;
JSch jsch = new JSch();
Session session = jsch.getSession(username, host);
session.setProxy(new ProxySOCKS5("127.0.0.1"));//路由用本地
session.setPassword(pass); // 设置密码
session.setUserInfo(new MyUserInfo(s)); //需要实现Jsch包中的UserInfo,UIKeyboardInteractive接口，用以保存用户信息，以及进行键盘交互式认证并执行命令。
Properties config = new Properties();
config.put("StrictHostKeyChecking", "no");//在代码里需要跳过检测。否则会报错找不到主机
session.setConfig(config); // 为Session对象设置properties
session.setTimeout(timeout); // 设置timeout时间
session.connect(); // 通过Session建立与远程服务器的连接回话

ChannelShell channelShell = (ChannelShell) session.openChannel("shell");
PipedInputStream pipeIn = new PipedInputStream();
PipedOutputStream pipeOut = new PipedOutputStream(pipeIn);
channelShell.setInputStream(pipeIn);

ByteArrayOutputStream output = new ByteArrayOutputStream();
channelShell.setOutputStream(output);
channelShell.connect(timeout);

output.reset();
pipeOut.write(("\n").getBytes());
wateForuser(output);

//命令最好一个一个执行，不然可能会出现，先后顺序错乱
sendFile(session,new File("D:\\shellwork\\d.xml"));//上传文件
exec("service cloud_ds restart",pipeOut,output);//服务重启
String status=exec("systemctl status cloud_ds",pipeOut,output);//查看服务状态获取返回值
log.info("===================="+status);
pipeOut.close();
pipeIn.close();
channelShell.disconnect();
session.disconnect();
}

private void sendFile(Session session, File file) {
log.info("put file {}", file.getName());
try {
Channel channel = session.openChannel("sftp");
channel.connect();
ChannelSftp c = (ChannelSftp) channel;
int mode = ChannelSftp.OVERWRITE;
c.put(file.getAbsolutePath(), "./", mode);
c.quit();
c.disconnect();
channel.disconnect();
} catch (Exception e) {
log.error("上传文件失败 {} -{} -{}", session.getHost(), file.getName(), e.getLocalizedMessage());
}
}

private String exec(String cmd, PipedOutputStream pipeOut, ByteArrayOutputStream output) throws IOException {
pipeOut.write((cmd + "\n").getBytes());
return wateFor("#", output);
}

private void wateForuser(ByteArrayOutputStream output) {

long start = System.currentTimeMillis();
while (true) {
String str = new String(output.toByteArray());
if (StringUtils.hasText(str)) {
if (str.indexOf("#") >= 0 || str.indexOf("$") >= 0) {
output.reset();
return;
}
}
if (System.currentTimeMillis() - start > timeout) {
throw new RuntimeException("登录时等待超时");
} else {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}
}

private String wateFor(String con, ByteArrayOutputStream output) {
long start = System.currentTimeMillis();
String str = null;
while (true) {
str = output.toString();
if (str.indexOf(con) >= 0) {
output.reset();
return str;
}
if (System.currentTimeMillis() - start > timeout) {
throw new RuntimeException("等待超时");
} else {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
}
}
}
}