Conectar vía SSH con Java

A continuación os vamos a explicar, a través de un ejemplo práctico, como establecer una

conexión una SSH con el lenguaje de programación Java. Intentaremos explicarlo mediante
un código sencillo que pueda ser entendido por cualquier tipo de nivel de usuarios. No nos
complicaremos mucho con esto y trataremos que la práctica sea entendible y puedas
llevarla a cabo en los proyectos que implementes de aquí en adelante.

¿Cómo empezar?

Lo primero que tenemos que hacer para implementar el proyecto es agregar las
dependencias:

<dependency>
<groupId>com.jcraftgroupId>
<artifactId>jschartifactId>
<version>0.1.53version>
<type>jartype>
dependency>

Como os habréis dado cuenta, para este sencillo ejercicio vamos a utilizar jCraft, una
librería que nos ayudará en nuestra misión de establecer una conexión SSH. Podéis obtener
más información en la web oficial de la librería de la que os estamos hablando.

¿Y ahora qué?

Pues lo siguiente que tenemos que hacer es crear el componente que utilizaremos para
conectar y ejecutar comandos SSH:

package co.com.mm.ssh;

import com.jcraft.jsch.ChannelExec;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
* Clase encargada de establecer conexión y ejecutar comandos SSH.
*/
public class SSHConnector {

/**
* Constante que representa un enter.
*/
private static final String ENTER_KEY = "n";
/**
* Sesión SSH establecida.
*/
private Session session;

/**
* Establece una conexión SSH.
*
* @param username Nombre de usuario.
* @param password Contraseña.
* @param host Host a conectar.
* @param port Puerto del Host.
*
* @throws JSchException Cualquier error al establecer
* conexión SSH.
* @throws IllegalAccessException Indica que ya existe una conexión
* SSH establecida.
*/
public void connect(String username, String password, String host,
int port)
throws JSchException, IllegalAccessException {
if (this.session == null || !this.session.isConnected()) {
JSch jsch = new JSch();
 this.session = jsch.getSession(username, host, port);
this.session.setPassword(password);

// Parametro para no validar key de conexion.

this.session.setConfig("StrictHostKeyChecking", "no");

this.session.connect();
} else {
throw new IllegalAccessException("Sesion SSH ya iniciada.");
}
}

/**
* Ejecuta un comando SSH.
*
* @param command Comando SSH a ejecutar.
*
* @return
*
* @throws IllegalAccessException Excepción lanzada cuando no hay
* conexión establecida.
* @throws JSchException Excepción lanzada por algún
* error en la ejecución del comando
* SSH.
* @throws IOException Excepción al leer el texto arrojado
* luego de la ejecución del comando
* SSH.
*/
public final String executeCommand(String command)
throws IllegalAccessException, JSchException, IOException {
if (this.session != null && this.session.isConnected()) {

// Abrimos un canal SSH. Es como abrir una consola.

ChannelExec channelExec = (ChannelExec) this.session.
openChannel("exec");

InputStream in = channelExec.getInputStream();

// Ejecutamos el comando.
channelExec.setCommand(command);
channelExec.connect();

// Obtenemos el texto impreso en la consola.

BufferedReader reader = new BufferedReader(new
InputStreamReader(in));
StringBuilder builder = new StringBuilder();
String linea;

while ((linea = reader.readLine()) != null) {

builder.append(linea);
builder.append(ENTER_KEY);
}

// Cerramos el canal SSH.

channelExec.disconnect();

// Retornamos el texto impreso en la consola.

 return builder.toString();
} else {
throw new IllegalAccessException("No existe sesion SSH
iniciada.");
}
}

/**
* Cierra la sesión SSH.
*/
public final void disconnect() {
this.session.disconnect();
}
}

Para terminar, tenemos que implementar la clase que se encargará de utilizar el código que
hemos publicado anteriormente para llevar a cabo la funcionalidad:

package co.com.mm.ssh;

import com.jcraft.jsch.JSchException;
import java.io.IOException;

public class SSHConnection {

private static final String USERNAME = "us_prog";

private static final String HOST = "localhost";
private static final int PORT = 22;
private static final String PASSWORD = "programacion";

public static void main(String[] args) {

try {
SSHConnector sshConnector = new SSHConnector();

sshConnector.connect(USERNAME, PASSWORD, HOST, PORT);

String result = sshConnector.executeCommand("ls -l");
sshConnector.disconnect();

System.out.println(result);
} catch (JSchException ex) {
ex.printStackTrace();

System.out.println(ex.getMessage());
} catch (IllegalAccessException ex) {
ex.printStackTrace();

System.out.println(ex.getMessage());
} catch (IOException ex) {
ex.printStackTrace();

System.out.println(ex.getMessage());
}
}
}
Ya solo tendrás que editar el usuario, la contraseña, el host y el puerto para que funcione
con vuestras propias credenciales. Y eso sería todo, ¿verdad que no ha sido tan difícil?

Y este ha sido el tutorial sobre conectar vía SFTP con Java, esperamos que te haya gustado
y sepas aplicarlo en tus futuros proyectos. Ya sabes que si nos quieres proponer un tema
que quieres ver reflejado como un tutorial o como una práctica, solo tienes que hacer uso
del área de comentarios de un poco más abajo. Por el contrario, si quieres enviarnos tus
propios tutoriales, puedes hacerlo a través de la intranet de usuarios que está habilitada para
ello, a través del menú Enviar Tutorial. Ya sabes, ayúdanos a crecer con tus conocimientos.
¡Un saludo y feliz código!

Vía: aquiseprograma.co