Einzelner Administratorcomputer für Systeme mit nur regulärem Konto im Netzwerk

Wie kann ich Systeme mit nur einem regulären Konto mit Verwaltungsaufgaben haben, die von einem einzelnen Computer verwaltet werden?

Ich möchte einfach in der Lage sein, Software auf allen Computern von einem einzigen System hinzuzufügen / zu entfernen. Großhandel - nicht einzeln bei jedem Computer anmelden und das tun, was getan werden muss. Ich kann das physisch oder per SSH tun, aber mit ungefähr hundert Computern ist das nicht wirklich eine Option, die ich in Betracht ziehen möchte.

Um mehrere Computer von einem zentralen Computer aus zu verwalten, können Sie versuchen, eine Systemverwaltungsplattform wie Puppet zu erlernen . Sie können mehrere Maschinen (Puppen) von einer Hauptmaschine (Puppenmeister) aus verwalten. Abhängig von Ihrem Szenario ist es vielleicht etwas übertrieben, aber es ist ein hervorragendes Werkzeug, um viele Maschinen von einem zentralen Kontrollpunkt aus zu verwalten. Es macht es auch sehr einfach, neue Maschinen einzurichten (oder die alten neu zu installieren), da Sie alle Konfigurationen, Paketlisten usw. vom Server abrufen können.

Hier ist ein Link zu einer Ubuntu -Anleitung zum Installieren und Testen von Puppetmaster.

Administratoren ausblenden

Auf jedem System wird mindestens ein Administrator benötigt, da in Ubuntu ein bestimmtes Root-Konto deaktiviert ist ^* . Trotzdem wäre es möglich, diesen Benutzer "Administrator" vor der GDM-Anmeldung zu verstecken, indem die folgende Zeile hinzugefügt wird /etc/gdm/custom.conf:

[greeter]
Exclude=nobody,administrator

Wir können den Lesezugriff von nicht administrativen Benutzern weiter einschränken /home/administrator/.

Für Verwaltungsaufgaben anmelden wir lokal als Benutzer Administrator (zB auf der Kommandozeile oder durch die Wahl anderer in der GUI) oder remote über ssh.

Definieren Sie ssh_config

Um einen Befehl an mehrere Remotecomputer zu senden, müssen wir eine lokale Konfigurationsdatei definieren, in der ~/.ssh/ssh_configwir Details auflisten, die für die Anmeldung an unseren Remotecomputern erforderlich sind, und in denen wir geeignete Namen für die Clients definieren können:

# ssh configuration
Host remote1
    HostName 192.168.0.1
    Port 22
    User USERNAME

Host remote2
    HostName 192.168.0.2
    Port 22
    User USERNAME

Möglicherweise sind zusätzliche Optionen erforderlich, um die Sitzungsdetails weiter zu steuern (z. B. Deaktivieren der Kennwortauthentifizierung).

Führen Sie den Befehl auf mehreren Clients aus

Wir schreiben jetzt ein Skript, das eine Verbindung zu einem Client nach dem anderen herstellt, um einen bestimmten Befehl auszuführen:

#!/bin/bash

# run a command on multiple remotes   

REMOTES=$1;shift
COMMAND=$1;shift

for remote in $REMOTES
do
    echo $remote
    ssh -oConnectTimeout=10 $remote $COMMAND
done

Wenn dieses Skript benannt wurde, können remote_command.shwir jeden Befehl auf unseren Remotecomputern 1-X ausführen, indem wir Folgendes aufrufen:

remote_command "remote1 remote2 ... remote<X>" "<COMMAND>" > remote_command.log

Abhängig von den individuellen Anforderungen können wir eine Liste für $ REMOTES aus einer Datei lesen oder ein reguläres Muster für die Namen der Fernbedienungen verwenden, um die Verwendung von Skripten zu vereinfachen. Wenn sich Remoteclients nicht ändern, können wir auch alle Namen in diesem Skript codieren, um es nur mit dem Befehl aufzurufen.

_{* Das erneute Aktivieren des Root-Kontos (durch Definieren eines gültigen Kennworts für root mit passwd root <password>in einer Root-Shell) wird nicht empfohlen, da die Nachteile überwiegen.}

Es ist weder billig noch Open Source, aber vielleicht kann Canonicals Landschaft helfen.

Wenn Sie Ihr eigenes lokales Repo verwenden (wie ich denke, wenn Sie an einer Schule arbeiten, um die Bandbreitenanforderungen zu senken), können Sie einfach eine Debatte mit den Abhängigkeiten der gewünschten Software führen. Wenn Sie dann das Deb aktualisieren, gibt es einen Cron-Job für Installationsupdates, der als Root ausgeführt wird, oder was auch immer auf magische Weise geschieht. Sie benötigen nicht an jedem PC eine große Menge an direkter Steuerung. Ich würde es mit Paketmanipulation tun. Sie können sogar einmalige Ausführungsskripte auf diese Weise pushen, wenn in die Deb eine "Post-Install-Task" integriert ist.

Ich kenne keine Internet-Cafe-Software, die dies tun würde, und ich denke, so etwas wie Puppet oder Chef wäre ein Overkill. Sie können ein sehr einfaches Setup basierend auf SSH erstellen, das funktionieren würde.

Nehmen wir an, Sie haben 20 Clients (10.0.0.101 bis 10.0.0.120) und 1 Verwaltungsstation (10.0.0.1).

Alle folgenden Schritte können zunächst auf einem Client getestet werden, um die Dinge zu testen. Die Ersteinrichtung muss auf allen Clients manuell durchgeführt werden.

Schritt 1: Machen Sie es sicherer (optional?)

Erstellen Sie auf allen Clients eine Firewall-Regel, um nur neue Verbindungen ab 10.0.0.1 zu akzeptieren

Vielleicht können Sie eine weitere Frage dazu stellen. Ich kann auch helfen iptables, habe aber keine Erfahrung mit den neuen Ubuntu-Firewall-Regeln.

Schritt 2: Stellen Sie eine Verbindung her

Auf allen Clients muss der SSH-Dienst ausgeführt werden.

1. Erstellen Sie ein separates Nicht-Root-Konto auf der Management Station Station.
2. Führen Sie aus ssh-keygen, um ein SSH-Schlüsselpaar zu erhalten. Geben Sie kein Passwort ein.
3. Erstellen Sie ein separates Konto auf den Clients. Takkat erwähnte, wie man es aus dem Gnome-Anmeldefenster ausschließt.

4. Fügen Sie das Konto Sudoers hinzu (z sudo visudo. B. mit ). Fügen Sie diese Zeile hinzu:

   aptaccount1 ALL=(silktree) NOPASSWD: /usr/bin/apt-get

   NOPASSWD ist wichtig, da die Installationen ausgeführt werden müssen, ohne dass Sie für jeden Client nach einem Kennwort gefragt werden müssen.

Jetzt können Sie testen. Führen Sie auf Ihrer Management-Workstation Folgendes aus:

ssh 10.0.0.101 sudo apt-get update

Schritt 3: Verbinden Sie alle parallel

Hier kommt mein Beitrag ins Spiel. Ich habe dieses Skript ungefähr 3 Jahre lang verwendet und bin sehr zufrieden damit. Es führt einen ssh-Befehl parallel zu vielen Knoten aus, die die Ausgabe und / oder Fehler gut drucken.

Sie müssten Ruby auf der Management Station installieren apt-get install rubyund alle Hosts Ihrer Clients in einer Liste in / etc / verwaltete Clients wie folgt einfügen:

n01
n02
n03
n04

Und auch auf der Management Station hinzufügen zu /etc/hosts:

10.0.0.101 n01
10.0.0.102 n02
10.0.0.103 n03
10.0.0.103 n04

Speichern Sie dann dieses Skript in /usr/local/bin/on-all-nodes-run

#!/usr/bin/ruby

CLIENTS_FILE =  "/etc/managed-clients"

require "open3"

# Non-interactive, no password asking, and seasonable timeouts
SSH_OPTIONS = ["-o PreferredAuthentications=publickey,hostbased,gssapi,gssapi-with-mic",
               "-o ForwardX11=no",
               "-o BatchMode=yes",
               "-o SetupTimeOut=5",
               "-o ServerAliveInterval=5",
               "-o ServerAliveCountMax=2"
              ].join(" ")

SSH    = "/usr/bin/ssh #{SSH_OPTIONS}"
MKDIR  = "/bin/mkdir"

raise "Pleae give this command at least one argument" if ARGV.size < 1
COMMAND = ARGV[0..-1].join(' ')

output_o = {}
output_e = {}


IO_CONNECTIONS_TO_REMOTE_PROCESSES = {}

def on_all_nodes(&block)
  nodes = []
  File.open(CLIENTS_FILE) do |f|
    while line = f.gets
      i = line.split(' ').first
      nodes.push(i)
    end
  end
  nodes.sort.each {|n| block.call(n)}
end


# Create processes
on_all_nodes do |node|
  stdin, stdout, stderr = Open3.popen3("#{SSH} #{node} \"#{COMMAND}\"")
  IO_CONNECTIONS_TO_REMOTE_PROCESSES[node] = [stdin, stdout, stderr]
end


has_remote_errors = false

# Collect results
on_all_nodes do |node|
  stdin, stdout, stderr = IO_CONNECTIONS_TO_REMOTE_PROCESSES[node]

  stdin.close

  e_thread = Thread.new do
    while line = stderr.gets
      line.chomp!
      STDERR.puts "#{node} ERROR: #{line}"
      has_remote_errors = true
    end
  end

  o_thread = Thread.new do
    while line = stdout.gets
      line.chomp!
      puts "#{node}      : #{line}"
    end
  end

  # Let the threads finish
  t1 = nil
  t2 = nil
  while [t1, t2].include? nil
    if t1.nil?
      t1 = e_thread.join(0.1) # Gives 1/10 of a second to STDERR
    end
    if t2.nil?
      t2 = o_thread.join(0.1) # Give 1/10 of a second to STDOUT
    end
  end

end


exit(1) if has_remote_errors

Der Code wurde auf guten Codierungsstil überprüft und es gibt hier einige Screenshots: /codereview/1180/ruby-script-on-all-nodes-run-for-teaching, aber ich habe nie Zeit bekommen um diese Vorschläge vorzustellen. Der Code funktioniert so wie er ist.

Test wie folgt:

on-all-nodes-run echo hi
n01      : hi
n02      : hi
n03 ERROR: Timeout, server not responding.
n04      : hi

Schritt 4: Installieren Sie die Software parallel

Jetzt sollten Sie in der Lage sein, Software wie diese zu installieren und zu aktualisieren (sorry, ich habe nur das showBeispiel mit Eignung, aber es sollte möglich sein, dasselbe mit zu tun apt-get):

on-all-nodes-run sudo aptitude show pbzip2 \| grep State
n01      : State: not installed
n02      : State: not installed
n03 ERROR: Timeout, server not responding.
n04      : State: not installed

on-all-nodes-run echo "Yes" \| sudo apt-get install pbzip2
...

on-all-nodes-run sudo aptitude show pbzip2 \| grep State
n01      : State: installed
n02      : State: installed
n03 ERROR: Timeout, server not responding.
n04      : State: installed

Schlussbemerkung

Wenn Sie mehr als 10 bis 20 Clients haben , sollten Sie zusätzlich zu dem obigen Skript eine Möglichkeit finden, die Festplatten mit etwas wie Perceus erneut bereitzustellen . Auf diese Weise können Sie sich Zeit sparen (Hinzufügen eines neuen Clients usw.) und sicherstellen, dass auf allen Clients alles gleich ist. In der Praxis benutze ich on-all-nodes-run100 Mal pro Jahr. Ich stelle mir einige Kunden einige Male im Jahr mit Perceus vor.