Automatyzacja ssh-copy-id

Mam dowolną liczbę serwerów z tą samą kombinacją użytkownik / przepustka. Chcę napisać skrypt (który wywołuję raz), aby

ssh-copy-id user@myserver

jest wywoływany dla każdego serwera. Ponieważ wszyscy mają tego samego użytkownika / hasło, powinno to być łatwe, ale ssh-copy-idchcę, aby wpisywać hasło osobno za każdym razem, co jest sprzeczne z celem mojego skryptu. Nie ma opcji wprowadzenia hasła, tj ssh-copy-id -p mypassword user@myserver.

Jak napisać skrypt, który automatycznie wypełnia pole hasła, gdy ssh-copy-ido to poprosi?

Spójrz na sshpass . Umieść swoje hasło w pliku tekstowym i zrób coś takiego:

$ sshpass -f password.txt ssh-copy-id user@yourserver

Możesz użyć funkcji oczekuj, aby nasłuchiwać monitu o hasło i wysłać hasło:

#!/usr/bin/expect -f
spawn ssh-copy-id $argv
expect "password:"
send "YOUR_PASSWORD\n"
expect eof

Zapisz skrypt, uczyń go wykonywalnym i wywołaj go w następujący sposób: ./login.expect user@myserver

Odpowiedź quanty jest całkiem dobra, ale wymaga wpisania hasła w pliku tekstowym.

Ze strony podręcznika „sshpass”:

Jeśli nie podano żadnej opcji, sshpass odczytuje hasło ze standardowego wejścia.

Więc, co możesz zrobić, to przechwycić hasło raz podczas skryptu, zapisać je w zmiennej, powtórzyć hasło i potokować, aby sshpass jako dane wejściowe.

Robię to cały czas i działa dobrze. Przykład: echo "Please insert the password used for ssh login on remote machine:" read -r USERPASS for TARGETIP in $@; do echo "$USERPASS" | sshpass ssh-copy-id -f -i $KEYLOCATION "$USER"@"$TARGETIP" done

Jest to problem z ssh-copy-id; dodaje również klucz przy każdym uruchomieniu. Jeśli automatyzujesz ten proces, twój plik autoryzowanych kluczy szybko zapełnia się powielonymi kluczami. Oto program w języku Python, który pozwala uniknąć obu problemów. Działa z serwera kontrolnego i umieszcza klucze z jednego zdalnego serwera na innym zdalnym serwerze.

import subprocess
def Remote(cmd,IP):
    cmd = '''ssh root@%s '''%(IP)+cmd
    lines = subprocess.check_output(cmd.split())
    return '\n'.join(lines)
source = '123.456.78.90'
target = '239.234.654.123'
getkey = 'cat /root/.ssh/id_rsa.pub'
getauth = 'cat /root/.ssh/authorized_keys'
sourcekey = Remote(getkey, source).replace('\n','').strip()
authkeys = Remote(getauth, target).replace('\n','').strip()
if sourcekey not in authkeys: 
    keycmd=''' echo "%s" >>/root/.ssh/authorized_keys; 
    chmod 600 /root/.ssh/authorized_keys '''%(sourcekey) # A compound shell statement
    print 'Installed key', Remote(keycmd,target)
else: print 'Does not need key'

Zamiast wpisywać hasła wielokrotnie można wykorzystać psshi jego -Aprzejście na zachęty dla niego raz, a następnie karmić hasło do wszystkich serwerów na liście.

UWAGA: Korzystanie z tej metody nie pozwala jednak na jej użycie ssh-copy-id, dlatego konieczne będzie wdrożenie własnej metody dołączania pliku klucza pub SSH do pliku konta zdalnego ~/.ssh/authorized_keys.

Przykład

Oto przykład, który wykonuje zadanie:

$ cat ~/.ssh/my_id_rsa.pub                    \
    | pssh -h ips.txt -l remoteuser -A -I -i  \
    '                                         \
      umask 077;                              \
      mkdir -p ~/.ssh;                        \
      afile=~/.ssh/authorized_keys;           \
      cat - >> $afile;                        \
      sort -u $afile -o $afile                \
    '
Warning: do not enter your password if anyone else has superuser
privileges or access to your account.
Password:
[1] 23:03:58 [SUCCESS] 10.252.1.1
[2] 23:03:58 [SUCCESS] 10.252.1.2
[3] 23:03:58 [SUCCESS] 10.252.1.3
[4] 23:03:58 [SUCCESS] 10.252.1.10
[5] 23:03:58 [SUCCESS] 10.252.1.5
[6] 23:03:58 [SUCCESS] 10.252.1.6
[7] 23:03:58 [SUCCESS] 10.252.1.9
[8] 23:03:59 [SUCCESS] 10.252.1.8
[9] 23:03:59 [SUCCESS] 10.252.1.7

Powyższy skrypt ma ogólnie taką strukturę:

$ cat <pubkey> | pssh -h <ip file> -l <remote user> -A -I -i '...cmds to add pubkey...'

psshSzczegóły na wysokim poziomie

• cat <pubkey> wysyła plik klucza publicznego do pssh
• psshużywa -Iprzełącznika do pobierania danych przez STDIN
• -l <remote user> to konto zdalnego serwera (zakładamy, że masz taką samą nazwę użytkownika na serwerach w pliku IP)
• -Akaże psshpoprosić o podanie hasła, a następnie użyć go ponownie dla wszystkich serwerów, z którymi się łączy
• -ikaże psshwysyłać dane wyjściowe do STDOUT zamiast przechowywać je w plikach (zachowanie domyślne)
• '...cmds to add pubkey...'- to jest najtrudniejsza część tego, co się dzieje, więc sama to rozwiążę (patrz poniżej)

Polecenia uruchamiane na zdalnych serwerach

Oto polecenia, które psshbędą uruchamiane na każdym serwerze:

'                                         \
  umask 077;                              \
  mkdir -p ~/.ssh;                        \
  afile=~/.ssh/authorized_keys;           \
  cat - >> $afile;                        \
  sort -u $afile -o $afile                \
'

• ustaw umask użytkownika zdalnego na 077, dzięki temu wszelkie katalogi lub pliki, które będziemy tworzyć, będą miały odpowiednio ustawione uprawnienia:

  $ ls -ld ~/.ssh ~/.ssh/authorized_keys
  drwx------ 2 remoteuser remoteuser 4096 May 21 22:58 /home/remoteuser/.ssh
  -rw------- 1 remoteuser remoteuser  771 May 21 23:03 /home/remoteuser/.ssh/authorized_keys
  

• utwórz katalog ~/.sshi zignoruj ​​ostrzeżenie, jeśli już tam jest

• ustaw zmienną, $afileze ścieżką do pliku autoryzowanych_kluczy
• cat - >> $afile - weź dane wejściowe ze STDIN i dołącz do pliku uprawnione klucze
• sort -u $afile -o $afile - jednoznacznie sortuje plik uprawniony_klucz i zapisuje go

UWAGA: Ten ostatni bit dotyczy obsługi przypadku, w którym powyższe uruchamiane są wielokrotnie na tych samych serwerach. Pozwoli to wyeliminować wielokrotne dołączanie Twojego klucza pub.

Zwróć uwagę na pojedyncze tyknięcia!

Zwróć także szczególną uwagę na fakt, że wszystkie te polecenia są zagnieżdżone w pojedynczych cudzysłowach. To ważne, ponieważ nie chcemy $afilebyć poddawani ocenie, dopóki nie zostanie wykonana na zdalnym serwerze.

'               \
   ..cmds...    \
'

Rozszerzyłem powyższe, aby łatwiej było je tutaj przeczytać, ale generalnie uruchamiam to wszystko w jednym wierszu:

$ cat ~/.ssh/my_id_rsa.pub | pssh -h ips.txt -l remoteuser -A -I -i 'umask 077; mkdir -p ~/.ssh; afile=~/.ssh/authorized_keys; cat - >> $afile; sort -u $afile -o $afile'

Materiał bonusowy

Dzięki zastosowaniu psshmożna zrezygnować z konieczności konstruowania pliki i albo zapewnienie dynamicznej zawartości przy użyciu -h <(...some command...)lub można utworzyć listę adresów IP, z wykorzystaniem innego pssh„s przełączników -H "ip1 ip2 ip3".

Na przykład:

$ cat .... | pssh -h <(grep -A1 dp15 ~/.ssh/config | grep -vE -- '#|--') ...

Powyższe można wykorzystać do wyodrębnienia listy adresów IP z mojego ~/.ssh/configpliku. Oczywiście możesz także użyć printfdo generowania dynamicznej treści:

$ cat .... | pssh -h <(printf "%s\n" srv0{0..9}) ....

Na przykład:

$ printf "%s\n" srv0{0..9}
srv00
srv01
srv02
srv03
srv04
srv05
srv06
srv07
srv08
srv09

Możesz także użyć seqdo generowania sformatowanych sekwencji liczb!

Referencje i podobne narzędzia do pssh

Jeśli nie chcesz używać psshtak jak ja to zrobiłem powyżej, dostępne są inne opcje.

• sshpt
• Moduł autoryzowanego_pliku_pliku Ansible

Jedno z równoległych narzędzi SSH (clusterssh, mssh, pssh) może być dla Ciebie odpowiednie.

Na przykład użyj cssh, aby zalogować się na wszystkich komputerach i samodzielnie dodać klucz.

Kilka rzeczy, które mogą pasować do rachunku:

• Funkcjonalnie to samo pytanie zadane również na stronie Jak mogę propagować mój klucz pub SSH na listę serwerów bez konieczności ciągłego wpisywania hasła? .
• Istnieje moduł perla, ale wydaje się, że nie jest zbytnio utrzymywany: https://github.com/Ruyk/pssh-copy-id

Jak wspomniano w innych odpowiedziach, sshpass jest prawdopodobnie najłatwiejszym rozwiązaniem.

Chcę podkreślić, jak kiepskim pomysłem jest:

1. Używaj zakodowanego hasła w swoich skryptach
2. Użyj tego samego hasła na WSZYSTKICH serwerach ... na przykład ... dlaczego !?
3. NIE używaj SSH public_key + hasło uwierzytelniania, jeśli nalegasz na to
4. Zapisz hasło w pliku tekstowym

Oto implementacja, która jest nieco bezpieczniejsza ...

#!/usr/bin/python3
import os
import getpass
import argparse

parser = argparse.argument_parser()
parser.add_argument('-l','--login', action='store', help='username')
parser.add_argument('-p','--port', action='store', default='22', help='port')
parser.add_argument('-L','--list', action='store', help='file list of IPs')
parser.add_argument('-i','--ip-address', action='store', nargs='+', metavar='host' help='ip or list of ips')

args = parser.parse_args()
if not args.login:
    print("You need a login, broski!")
    return 0

if args.list:
    ips = [i for i in open(args.list, 'r').readlines()]
    passwd = getpass.getpass('Password: ')

    for ip in ips:
        cmd = 'ssh-id-copy {0}@{1} -p {2}'.format(ip,args.port,passwd)            
        os.system('sshpass -p ' + passwd + ' ' + cmd)
        print("Key added: ", ip)   # prints if successful
        # ex: sshpass -p passwd ssh-id-copy [email protected]

elif args.host:
    ip = args.host
    cmd = 'ssh-id-copy {0}@{1} -p {2}'.format(ip,args.port,passwd)
    os.system('sshpass -p ' + passwd + ' ' + cmd)
    print("Key added: ", ip)   # prints if successful
else:
    print("No IP addresses were given to run script...")
    return 0