Comando ssh mais avançado.

Pessoal
Eu preciso do seguinte.
Tenho uma rede tcpip, que para executar um determinado programa, eu me conecto ao servidor via ssh.
Agora vamos a questão: Eu na máquina A, me conectando no servidor, via ssh em modo texto. Quero disparar um programa no servidor, mas que o mesmo seja executado na máquina a. Exemplo: eu disparo via ssh, o OpenOffice pela linha de comando(swriter), mas o mesmo deverá ser executado localmente. Ou seja o ssh avisa ao servidor que é para executar na máquina A. Pessoal eu sei que usando ssh em modo gráfico eu consigo, mas não é isto que eu quero. Enfatizo, usando ssh, conectado a um servidor, disparar um comando que o mesmo seja executado em um endereço TCP/IP e não no servidor.

ssh carlos-ba@10.0.7.4

senha


ação


o que você não conseguiu?

ssh root@ip

ai e so executar os comandos como se estivesse local...

Verifica o se no arquivo de configuração do /etc/ssh/sshd_config no servidor está habilitado para mostra o X dele:

X11Forwarding yes

Depois basta usar o comando:

ssh -X usuario@ip_do_servidor

depois pode digitar o nome da aplicação para mostrar graficamente na maquina que está acessando o servidor.

Se quiser pode executar direto, digitando:

ssh -X usuario@ip_do_servidor "comando da aplicacao"

Exemplo
ssh -X usuario@ip_do_servidor "gedit"

de uma lida
http://www.hardware.com.br/tutoriais/dominando-ssh/

Pessoal, acho que vocês não entenderam
É óbvio que com ssh eu me conecto no servidor e é claro que eu sei a sintaxe do comando.
Daí, qualquer comando que eu executar eu vou executar no SERVIDOR, na minha máquina, estará a tela de uma tty, EXECUTANDO NO SERVIDOR.
O que quero não é isto.
EU quero estar conectado no servidor, em uma janela na minha máquina, mas quero que através de um comando qualquer, digitado na tela do meu computador que está com um ssh aberto, abra o meu openoffice e não o openofice do servidor.
ENtenderam agora?
Uma maneira que eu pensei é eu estou conectado por ssh no servidor, e pelo mesmo ssh, se eu me conectar via ssh na minha máquina, ou seja um ssh dentro do outro, eu executaria o meu OpenOffice.
Mas eu acredito que deva ter uma maneira mais fácil de fazer isto.
Valeu

Porque vc quer fazer isso?, pela lógica o efeito vai ser o mesmo de digitar o nome do programa em um terminal local.

que terminal tu usa ele não tem suporte a abas, uma com ssh no servidor e outra na tua maquina normal ai quando vc rodar um comando ele roda na tua maquina.

Porque fazer isto, muito simples, vamos lá.
Este cliente usa um programa em linux que só funciona via ssh.
Logo, se este programa acionar o OpenOffice, estará sendo executado no servidor e nunca localmente.
A maior parte do terminais é tudo ltsp, então todo o processamento está no servidor.
Só que agora, enquanto ele não muda se software surviu a necessidade de que algumas coisas sejam executadas localmente.
Então em alguns computadores não serão mais ltsp, e sim rede tcp/ip. Só que para acessar este programa, continuaremos a usar o ssh, que é o que este programa suporta.
Por isto precisamos achar uma maneira de que o servidor, eu receber uma chamada ao OpenOffice(pessoal isto é um exemplo apenas tá), não abra o OpenOffice no servidor e sim abra localmente na máquina que está na rede.
Entenderam?

Cara desculpe mas ainda eu nao ententi o que você quer fazer ,
um exemplo com libreoffice , eu tenho um planilha no servidor onde todos acessam a mesma planilha
ela fica no servidor quando u abro essa planilha o libreoffice é executado na minha maquina e não no
servidor
seria isso ?

Sem problemas, explico quantas vezes eu puder.
Vamos pensar no seguinte:
Tenho 3 máquinas em uma rede. Um servidor, e duas máquinas funcionando em ltsp.
Apenas para os leigos saberem, quando eu tenho uma máquina ltsp, todo o processamento é feito no servidor.
Agora quero colocar uma quarta máquina, que estaria ligada por rede P2P e não mais por ltsp.
O programa que eu uso, funciona em modo texto. Logo em todas as máquinas, quando eu clico no programa, abre um konsole com o mesmo.
Só que na quarta máquina, eu tenho que me conectar via ssh, pois este programa só funciona no servidor, não funciona em rede tcp/ip e P2P.
Vamos imaginar que por dentro deste programa eu abra o OpenOffice, através de um comando no shell, swriter. Mesmo o programa sendo em modo texto, irá abrir na minha janela do servidor e nas máquinas LTSP o openoffice, certo?
Agora, na quarta máquina, só abriria se eu tivesse me conectado ao servidor via terminal gráfico, abriria o openoffice, mas sendo executado e processado no servidor e não na minha máquina local( a quarta máquina é rede P2P). Muito bem.
Então, o que quero é não me conectar via terminal gráfico nesta quarta máquina. Me conectar via ssh em modo texto e se eu mandar abrir o OpenOffice, que o mesmo abra localmente na quarta máquina e não no servidor. Mas para isto eu preciso de um comando que será disparado no servidor. O servidor irá identificar que não é para abrir no servidor e sim mandar um recado para a quarta máquina para que ela abra o OpenOffice e não o servidor.

Em sistemas operacionais bem antigos como o QNX 3.15 por exemplo, isto era feito de uma maneira super simples, lá cada máquina de uma rede P2P se chamada de nodos, e o servidor poderia ter vários terminais(ltsp a grosso modo) e também várias máquinas na rede (nodos). Caso eu quisesse executar um programa em um nodo localmente, mesmo que este programa estivesse no servidor, bastaria eu colocar entre colchetes o número do nodo, na linha de comando. [4]./swriter
O servidor entenderia que não é para abrir o openofice nele, e sim abrir e processar na máquina 4, ou seja o servidor avisa a máquina 4: "abre e executa apenas aí na tua máquina o openofice".

O que eu quero, apenas tirar o processamento e execução de alguns programas do servidor, mesmo estando conectado nele via ssh. Claro que o programa em modo texto vai estar funcionando no servidor, mas os programas auxiliares que este programa chamar, não estarão.

Foi o que eu mostrei aqui então:

$ ssh -X usuario@ip_do_servidor "gedit"

Você vai abrir o programa que tem no servidor, mas mostrando graficamente para você na estação que executou o comando.