Mudanças entre as edições de "Minicluster:Ssh"

De WikiLICC
Ir para: navegação, pesquisa
m (→‎Veja também)
m (→‎Setando SSH sem senha para usuários atuais)
 
(13 revisões intermediárias pelo mesmo usuário não estão sendo mostradas)
Linha 1: Linha 1:
−
==ssh-keygen: password-less SSH login==
+
Programas rodando com [[MPICH]] sobre várias máquinas precisam se comunicar com outras máquinas como se fossem o próprio usuário. Isto significa que o usuário precisa estar apto a se conectar com SSH nas máquinas escravo sem usar senha.
−
SSH is often used to login from one system to another without requiring passwords.
+
 
 +
'''Importante''': As permissões do arquivo tem que ser 600. Talvez umas configurações extras para /etc/hosts
 +
 
 +
== Setando SSH sem senha para usuários atuais ==
 +
Em uma máquina com [[Minicluster:NFS | NFS]] isto é fácil (não o caso ainda).  Conecte-se como o usuário e rode
 +
 
 +
[usuario@one]    $ ssh usuario@cell100 (será pedido senha)
 +
[usuario@cell100] $ ssh-keygen
 +
 
 +
* Tecle enter para confirmar o arquivo <code>.ssh/id_rsa</code>
 +
* Tecle Enter sem uma senha 2 vezes quando perguntado.  Isto criará dois novos arquivos no diretório <code>/home/usuario/.ssh</code>: sua chave privada (id_rsa) e sua chave pública  (id_rsa.pub).
 +
 
 +
[usuario@cell100] $ cd .ssh
 +
[usuario@cell100] $ ls
 +
 
 +
Crie um arquivo chamado <code>authorized_keys</code>.  Este arquivo é responsável por dizer quem é permitido SSH  nesta máquina como este usuário e sem senha.  A chave pública precisa ser adicionada neste arquivo
 +
 
 +
cat id_rsa.pub >> authorized_keys
 +
 
 +
A permissão deve ser somente para o usuário:
 +
 
 +
chmod 600 authorized_keys
 +
 
 +
Neste ponto, você deveria estar apto a logar-se sem senha na própria máquina
 +
 
 +
ssh localhost
 +
 
 +
=== Sem senha para o root ===
 +
Para permitir que o usuário root não informe a senha utilize no mestre
 +
[root@one] $escravo=cell108
 +
[root@one] ssh $escravo mkdir -p .ssh
 +
[root@one] cat .ssh/id_rsa.pub | ssh $escravo 'cat >> .ssh/authorized_keys'
 +
uma vez para cada nó escravo. Ou seja, mude $escravo=cell109, e use os dois comandos seguintes. Depois disso não deveria ser necessário mais informar a senha.
 +
 
 +
=== Script para todos os usuários atuais ===
 +
Ao invés de se tornar cada usuário e fazer isso a mão, o processo pode ser scripted.  Como root, edite o texto
 +
 
 +
<pre>
 +
[root@one]$ vi autoriza_ssh.sh
 +
#!/bin/bash
 +
# Cria uma chave SSH para cada usuario existente e cria
 +
#  um arquivo  authorized_keys com chave publica.
 +
 
 +
# Diretorio home contendo os usuarios
 +
homeDirs=/shared/home
 +
 
 +
for x in `ls $homeDirs`; do
 +
  echo Criando chave SSH para $x...
 +
 
 +
  if [[ -e $homeDirs/$x/.ssh/id_rsa.pub ]]; then
 +
    echo "$x ja tem uma chave publica"
 +
  else
 +
    su $x -c "ssh-keygen -N \"\"" 
 +
  fi
 +
 
 +
  cat $homeDirs/$x/.ssh/id_rsa.pub >> $homeDirs/$x/.ssh/authorized_keys
 +
  chown $x $homeDirs/$x/.ssh/authorized_keys
 +
  chmod 600 $homeDirs/$x/.ssh/authorized_keys
 +
 
 +
done
 +
</pre>
 +
 
 +
 
 +
Troque o valor de <code>homeDirs</code> para o valor correto.  (<code>homeDirs</code> é o diretório no sistema de arquivos montado  onde os diretórios de usuários são armazenados.)
 +
 
 +
 
 +
Troque a permissão do usuário para executável
 +
 
 +
:<code>chmod u+x autoriza_ssh.sh</code>
 +
 
 +
Rode o script
 +
 
 +
:<code>./autoriza_ssh.sh</code>
 +
 
 +
Será perguntado onde por os arquivos para cada usuário.
 +
(Faltou tempo para por no scritpt.)  Tecle enter e confirme o default.
 +
 
 +
== Password-Less SSH for Future Users ==
 +
Ideally, this script could be set to run every time a new user account is created.    Still, the above can be changed to an interactive script that takes a username to create an SSH key for, and you can run it whenever you create a new user.
 +
 
 +
Again, you'll need to change it to be executable and also correct the value of <code>homeDirs</code>.
 +
 
 +
<pre>
 +
#!/bin/bash
 +
# Creates an SSH key and an authorized_keys file for
 +
#  a username given as an argument.
 +
 
 +
# Directory containing user home directorys
 +
homeDirs=/home/shared
 +
 
 +
if ! [[ "$1" ]]
 +
then
 +
  echo "Usage: ./sshauthhostkeygen username"
 +
  exit 1
 +
fi
 +
 
 +
x=`echo $1`
 +
 
 +
echo Creating SSH key for $x...
 +
 
 +
if ! id $x > /dev/null 2>&1
 +
then
 +
  echo $x is not a valid user.
 +
  exit 1
 +
fi
 +
 
 +
if ! [[ -e $homeDirs/$x ]]; then
 +
  echo $x does not have a home directory.
 +
  exit 1
 +
fi
 +
 
 +
if [[ -e $homeDirs/$x/.ssh/id_rsa.pub ]]; then
 +
  echo "$x already has a public key"
 +
else
 +
  su $x -c "ssh-keygen -N \"\"" 
 +
fi
 +
 
 +
cat $homeDirs/$x/.ssh/id_rsa.pub >> $homeDirs/$x/.ssh/authorized_keys
 +
chown $x:$x $homeDirs/$x/.ssh/authorized_keys
 +
chmod 600 $homeDirs/$x/.ssh/authorized_keys
 +
</pre>
 +
 
 +
== Preventing Logins ==
 +
While this is necessary for processes running on behalf of the user, users probably shouldn't be able to do code development and other tasks on the worker nodes themselves.  To prevent shell logins (other than root), just run
 +
 
 +
:<code>touch /etc/nologin</code>
 +
 
 +
You'll still be able to SSH in as root and then <code>su</code> to that user.
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
  
−
A number of methods may be used for that to work properly, one of which is to setup a .rhosts file (permission 600) with its content being the name of the remote system you trust, followed by the username your trust:
 
  
−
    nickel.sao.nrc.ca cantin
+
==ssh-keygen: password-less SSH login==
  
−
would mean you trust user cantin from nickel.sao.nrc.ca to connect to your account, without requiring a password.
+
=== via .rhosts ===
 +
Uma maneira é criar o arquivo .rhosts com o nome do sistema remoto e usuário que você confia:
 +
[user] vi .rhosts
 +
outra.maquina.net usuario
 +
..
 +
[user] chmod 600 .rhosts
 +
Assim o usuario pode ser conectar de outra.maquina.net sem usar a senha.
  
−
But for that to work, SSH itself must be configured to trust .rhosts files (which it does not for most OpenSSH installations - but we do on most systems RCSG maintains), and the private/public key pair of each system must be properly set in the system-wide ssh_known_hosts public key file.
+
Mas, o SSH deve ser configurado para confiar em  .rhosts (que não é o padrão), e o par de chaves privada/pública de cada sistema deve ser propriamente setado no arquivo de chaves públicas ssh_known_hosts.
  
−
This, of course, requires help from the local systems administrator.
+
=== Método 2===
  
−
The second method does not require any help from the systems administrator. And it does not require modifications to the .rhosts file. Instead, it requires you generate your own personal set of private/public pair.
+
Não requer .rhosts e nem administrador. Requer apenas que você gere um par de chaves pública/privada.
  
 
ssh-keygen is used to generate that key pair for you. Here is a session where your own personal private/public key pair is created:
 
ssh-keygen is used to generate that key pair for you. Here is a session where your own personal private/public key pair is created:
Linha 47: Linha 191:
 
The example shown here generated keys on sodium by user cantin. If the public key generated, file .ssh/id_rsa.pub, was copied to your account, file .ssh/authorized_keys on nickel.sao.nrc.ca, then user cantin@sodium is allowed to SSH into your own account on nickel.sao.nrc.ca without the use of a password.
 
The example shown here generated keys on sodium by user cantin. If the public key generated, file .ssh/id_rsa.pub, was copied to your account, file .ssh/authorized_keys on nickel.sao.nrc.ca, then user cantin@sodium is allowed to SSH into your own account on nickel.sao.nrc.ca without the use of a password.
  
−
To summarize, a personal private/public key pair is generated using the ssh-keygen command. The public key is then copied onto a remote systems' .ssh/authorized_keys file. And you can now SSH to the remote systems's account without the use of a password.  
+
To summarize, a personal private/public key pair is generated using the ssh-keygen command. The public key is then copied onto a remote systems' .ssh/authorized_keys file. And you can now SSH to the remote systems's account without the use of a password.
  
 
==Veja também==
 
==Veja também==
 +
* http://debianclusters.org/index.php/Password-less_SSH_for_Users, funcionou seguindo estas informações
 +
 
* http://rcsg-gsir.imsb-dsgi.nrc-cnrc.gc.ca/documents/internet/node31.html
 
* http://rcsg-gsir.imsb-dsgi.nrc-cnrc.gc.ca/documents/internet/node31.html
 
* http://beowulf.org/archive/2005-June/013094.html
 
* http://beowulf.org/archive/2005-June/013094.html
 
* http://people.redhat.com/kzak/docs/rsh-rlogin-howto.html
 
* http://people.redhat.com/kzak/docs/rsh-rlogin-howto.html
 +
* http://www.linuxquestions.org/questions/linux-software-2/cant-rsh-without-password-dispite-following-howtos-183828/

Edição atual tal como às 18h17min de 6 de maio de 2012

Programas rodando com MPICH sobre várias máquinas precisam se comunicar com outras máquinas como se fossem o próprio usuário. Isto significa que o usuário precisa estar apto a se conectar com SSH nas máquinas escravo sem usar senha.

Importante: As permissões do arquivo tem que ser 600. Talvez umas configurações extras para /etc/hosts

Setando SSH sem senha para usuários atuais

Em uma máquina com NFS isto é fácil (não o caso ainda). Conecte-se como o usuário e rode 

[usuario@one]     $ ssh usuario@cell100 (será pedido senha)
[usuario@cell100] $ ssh-keygen
  • Tecle enter para confirmar o arquivo .ssh/id_rsa
  • Tecle Enter sem uma senha 2 vezes quando perguntado. Isto criará dois novos arquivos no diretório /home/usuario/.ssh: sua chave privada (id_rsa) e sua chave pública (id_rsa.pub).
[usuario@cell100] $ cd .ssh
[usuario@cell100] $ ls

Crie um arquivo chamado authorized_keys. Este arquivo é responsável por dizer quem é permitido SSH nesta máquina como este usuário e sem senha. A chave pública precisa ser adicionada neste arquivo 

cat id_rsa.pub >> authorized_keys

A permissão deve ser somente para o usuário: 

chmod 600 authorized_keys

Neste ponto, você deveria estar apto a logar-se sem senha na própria máquina 

ssh localhost

Sem senha para o root

Para permitir que o usuário root não informe a senha utilize no mestre 

[root@one] $escravo=cell108
[root@one] ssh $escravo mkdir -p .ssh
[root@one] cat .ssh/id_rsa.pub | ssh $escravo 'cat >> .ssh/authorized_keys'

uma vez para cada nó escravo. Ou seja, mude $escravo=cell109, e use os dois comandos seguintes. Depois disso não deveria ser necessário mais informar a senha.

Script para todos os usuários atuais

Ao invés de se tornar cada usuário e fazer isso a mão, o processo pode ser scripted. Como root, edite o texto 

[root@one]$ vi autoriza_ssh.sh
#!/bin/bash
# Cria uma chave SSH para cada usuario existente e cria
#  um arquivo  authorized_keys com chave publica.

# Diretorio home contendo os usuarios
homeDirs=/shared/home

for x in `ls $homeDirs`; do
  echo Criando chave SSH para $x...
  
  if [[ -e $homeDirs/$x/.ssh/id_rsa.pub ]]; then
    echo "$x ja tem uma chave publica"
  else
    su $x -c "ssh-keygen -N \"\""  
  fi

  cat $homeDirs/$x/.ssh/id_rsa.pub >> $homeDirs/$x/.ssh/authorized_keys
  chown $x $homeDirs/$x/.ssh/authorized_keys
  chmod 600 $homeDirs/$x/.ssh/authorized_keys

done


Troque o valor de homeDirs para o valor correto. (homeDirs é o diretório no sistema de arquivos montado onde os diretórios de usuários são armazenados.)


Troque a permissão do usuário para executável

chmod u+x autoriza_ssh.sh

Rode o script

./autoriza_ssh.sh

Será perguntado onde por os arquivos para cada usuário. (Faltou tempo para por no scritpt.) Tecle enter e confirme o default.

Password-Less SSH for Future Users

Ideally, this script could be set to run every time a new user account is created. Still, the above can be changed to an interactive script that takes a username to create an SSH key for, and you can run it whenever you create a new user.

Again, you'll need to change it to be executable and also correct the value of homeDirs. 

#!/bin/bash
# Creates an SSH key and an authorized_keys file for
#  a username given as an argument.

# Directory containing user home directorys
homeDirs=/home/shared

if ! [[ "$1" ]]
then
  echo "Usage: ./sshauthhostkeygen username"
  exit 1
fi

x=`echo $1`

echo Creating SSH key for $x...

if ! id $x > /dev/null 2>&1
then
  echo $x is not a valid user.
  exit 1
fi
  
if ! [[ -e $homeDirs/$x ]]; then
  echo $x does not have a home directory.
  exit 1
fi

if [[ -e $homeDirs/$x/.ssh/id_rsa.pub ]]; then
  echo "$x already has a public key"
else
  su $x -c "ssh-keygen -N \"\""  
fi

cat $homeDirs/$x/.ssh/id_rsa.pub >> $homeDirs/$x/.ssh/authorized_keys
chown $x:$x $homeDirs/$x/.ssh/authorized_keys
chmod 600 $homeDirs/$x/.ssh/authorized_keys

Preventing Logins

While this is necessary for processes running on behalf of the user, users probably shouldn't be able to do code development and other tasks on the worker nodes themselves. To prevent shell logins (other than root), just run

touch /etc/nologin

You'll still be able to SSH in as root and then su to that user.








ssh-keygen: password-less SSH login

via .rhosts

Uma maneira é criar o arquivo .rhosts com o nome do sistema remoto e usuário que você confia: 

[user] vi .rhosts
outra.maquina.net usuario
..
[user] chmod 600 .rhosts

Assim o usuario pode ser conectar de outra.maquina.net sem usar a senha.

Mas, o SSH deve ser configurado para confiar em .rhosts (que não é o padrão), e o par de chaves privada/pública de cada sistema deve ser propriamente setado no arquivo de chaves públicas ssh_known_hosts.

Método 2

Não requer .rhosts e nem administrador. Requer apenas que você gere um par de chaves pública/privada.

ssh-keygen is used to generate that key pair for you. Here is a session where your own personal private/public key pair is created: 

cantin@sodium:~> ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/cantin/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/cantin/.ssh/id_rsa.
Your public key has been saved in /home/cantin/.ssh/id_rsa.pub.
The key fingerprint is:
f6:61:a8:27:35:cf:4c:6d:13:22:70:cf:4c:c8:a0:23 cantin@sodium

The command ssh-keygen -t rsa initiated the creation of the key pair.

No passphrase was entered (Enter key was pressed instead).

The private key was saved in .ssh/id_rsa. This file is read-only and only for you. No one else must see the content of that file, as it is used to decrypt all correspondence encrypted with the public key.

The public key is save in .ssh/id_rsa.pub.

In this case, the content of file id_rsa.pub is 

ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEArkwv9X8eTVK4F7pMlSt45pWoiakFkZMw
G9BjydOJPGH0RFNAy1QqIWBGWv7vS5K2tr+EEO+F8WL2Y/jK4ZkUoQgoi+n7DWQVOHsR
ijcS3LvtO+50Np4yjXYWJKh29JL6GHcp8o7+YKEyVUMB2CSDOP99eF9g5Q0d+1U2WVdB
WQM= cantin@sodium

It is one line in length.

Its content is then copied in file .ssh/authorized_keys of the system you wish to SSH to without being prompted for a password.

The example shown here generated keys on sodium by user cantin. If the public key generated, file .ssh/id_rsa.pub, was copied to your account, file .ssh/authorized_keys on nickel.sao.nrc.ca, then user cantin@sodium is allowed to SSH into your own account on nickel.sao.nrc.ca without the use of a password.

To summarize, a personal private/public key pair is generated using the ssh-keygen command. The public key is then copied onto a remote systems' .ssh/authorized_keys file. And you can now SSH to the remote systems's account without the use of a password.

Veja também

Disponível em "http://hunter.mat.ufrgs.br/mediawiki/index.php?title=Minicluster:Ssh&oldid=3510"