如何实现一台机器管理多台root密码不同的机器

HalfCamel

rlogin或者ssh都可以，如果预算充足，可以搭建一个登录管理系统！

Purple_Grape

user { "root":
         ensure   => present,
         name     => "root",
         password => "SomeAlreadyEncryptedPassword";
   }

linuxpf

有结果了吗？

linuxpf

PUPPET就是集中管理多台服务器工具，缺点就是配置管理麻烦些；
像楼主这种情况也不用puppet的，建议用pssh或expect写脚本 实现；

gtuiw

我的实现方法就是每台机器都当作一台server,然后想执行什么命令,在一台机器上连接这些机器的端口,然后直接执行命令.
这方法类似于puppet的使用认证文件执行命令.我使用mac地址作认证信息.

很久没搞了,都不知道东南西北了.

我是使用ruby实现的,代码如下:

1. [b]Server[/b]
   
2.   1 require 'socket'
   
3.   2 require 'digest/sha1'
   
4.   3 require "openssl"
   
5.   4
   
6.   5 priv_key = OpenSSL::PKey::RSA.new(1024)
   
7.   6 pub_key = priv_key.public_key
   
8.   7
   
9.   8 host = ARGV[0] || 'localhost'
   
10.   9 port = (ARGV[1] || 8888).to_i
    
11. 10
    
12. 11 server = TCPServer.new(host, port)
    
13. 12
    
14. 13 sockets = [server]
    
15. 14
    
16. 15 while true
    
17. 16   ready = select(sockets)
    
18. 17   readable = ready[0]
    
19. 18   readable.each do |socket|
    
20. 19     if socket === server
    
21. 20       session = socket.accept
    
22. 21       temp = session.recv(100)
    
23. 22       recv_data = temp.unpack("m")
    
24. 23       if recv_data[0] === 'c8:2a:14:17:31:15'
    
25. 24         session.print pub_key
    
26. 25         exec_command = session.recv(1000)
    
27. 26         puts "Received data..."
    
28. 27         msg = priv_key.private_decrypt(exec_command)
    
29. 28         print msg
    
30. 29         puts "Executing command: #{msg}"
    
31. 30         `#{msg}`
    
32. 31       else
    
33. 32         puts "The message could not be validated!"
    
34. 33         puts false
    
35. 34       end
    
36. 35     end
    
37. 36   end
    
38. 37 end
    

复制代码

1. [b]Client[/b]
   
2.   1 #!/usr/bin/env ruby                                                                              
   
3.   2 require 'socket'                                                                                 
   
4.   3 require 'digest/sha1'                                                                           
   
5.   4 require "openssl"                                                                                
   
6.   5                                                                                                  
   
7.   6 RE = %r/(?:[^:\-]|\A)(?:[0-9A-F][0-9A-F][:\-]){5}[0-9A-F][0-9A-F](?:[^:\-]|\Z)/io               
   
8.   7 platform = RUBY_PLATFORM.downcase                                                               
   
9.   8 output = `#{platform =~ /linux/ ? '/sbin/ifconfig' : 'ifconfig'}`                                
   
10.   9                                                                                                  
    
11. 10 def parse(output)                                                                                
    
12. 11   lines = output.split(/\n/)                                                                     
    
13. 12   candidates = lines.select{|line| line =~ RE}                                                   
    
14. 13   raise 'no mac address candidates' unless candidates.first                                      
    
15. 14   candidates.map!{|c| c[RE].strip}                                                               
    
16. 15 end                                                                                             
    
17. 16                                                                                                  
    
18. 17 begin                                                                                            
    
19. 18   client = TCPSocket.open('localhost', 8888)                                                     
    
20. 19   puts "connected!\n\n"                                                                          
    
21. 20   macaddr = parse(output)                                                                        
    
22. 21   client.print macaddr.pack("m")                                                                 
    
23. 22   temp = ""                                                                                      
    
24. 23   6.times do                                                                                    
    
25. 24     temp << client.gets                                                                          
    
26. 25   end                                                                                            
    
27. 26   puts "Received public 1024 RSA key!\n\n"                                                      
    
28. 27   public_key = OpenSSL::PKey::RSA.new(temp)                                                      
    
29. 28                                                                                                  
    
30. 29   msg = 'echo "hello"'                                                                           
    
31. 30   command = public_key.public_encrypt("#{msg}")                                                  
    
32. 31   print "Sending the command...."                                                               
    
33. 32   client.send(command,0)                                                                        
    
34. 33   puts "sent!"                                                                                   
    
35. 34 rescue => e                                                                                      
    
36. 35   puts "Something terrible happened..."                                                         
    
37. 36   puts e                                                                                         
    
38. 37   retry                                                                                          
    
39. 38 end                                                                                             
    
40. 39 client.close   
    

复制代码

xiaoyu_13

上ssh公钥就行了

tingshow163

撸主能说下你为什么非要搞那么复杂吗?

ssh密钥登录不是妥妥的吗?

wcjiang

通过SSH互信可以实现