Automatisieren des Server-Setups mit Ansible unter Ubuntu 18.04

Einführung

Wenn Sie zum ersten Mal einen neuen Ubuntu 18.04-Server erstellen, sollten Sie im Rahmen der Grundkonfiguration einige Konfigurationsschritte ausführen. Dies erhöht die Sicherheit und Benutzerfreundlichkeit Ihres Servers und bildet eine solide Grundlage für nachfolgende Aktionen.

Sie können diese Schritte zwar manuell ausführen, die Automatisierung des Prozesses spart jedoch Zeit und verringert menschliches Versagen. Mit der Verbreitung von containerisierten Anwendungen und Mikrodiensten spielt die Serverautomatisierung nun eine wesentliche Rolle in der Systemadministration. Es ist auch eine Möglichkeit, Standardverfahren für neue Server festzulegen.

In diesem Handbuch wird erläutert, wie SieAnsible verwenden, um die in unserenInitial Server Setup Guide enthaltenen Schritte zu automatisieren. Ansible ist ein modernes Konfigurationsmanagement-Tool, mit dem die Bereitstellung und Konfiguration von Remotesystemen automatisiert werden kann.

Check vor dem Flug

Um das in diesem Handbuch beschriebene automatische Setup auszuführen, benötigen Sie:

Ansible wird entweder auf Ihrem lokalen Computer oder auf einem Remote-Server installiert, den Sie alsAnsible Control Node eingerichtet haben. Sie können Schritt 1 des TutorialsHow to Install and Configure Ansible on Ubuntu 18.04 ausführen, um diese Einrichtung zu erhalten.
Root-Zugriff auf einen oder mehrere Ubuntu 18.04-Server, die von Ansible verwaltet werden.

Bevor Sie ein Playbook ausführen, müssen Sie sicherstellen, dass Ansible über SSH eine Verbindung zu Ihren Servern herstellen undAnsible modules mit Python ausführen kann. In den nächsten beiden Abschnitten wird beschrieben, wie Sie Ihr Ansible-Inventar so einrichten, dass es Ihre Server enthält, und wie Sie Ad-hoc-Ansible-Befehle ausführen, um die Konnektivität und die gültigen Anmeldeinformationen zu testen.

Inventardatei

Dasinventory file enthält Informationen zu den Hosts, die Sie mit Ansible verwalten. Sie können zwischen einem und mehreren hundert Servern in Ihre Inventardatei aufnehmen, und Hosts können in Gruppen und Untergruppen organisiert werden. Die Inventardatei wird auch häufig verwendet, um Variablen festzulegen, die nur für bestimmte Hosts und Gruppen gültig sind, damit sie in Playbooks und Vorlagen verwendet werden können. Einige Variablen können sich auch auf die Art und Weise auswirken, wie ein Playbook ausgeführt wird, z. B. die Variableansible_python_interpreter, die wir gleich sehen werden.

Um den Inhalt Ihres Standard-Ansible-Inventars zu überprüfen, öffnen Sie die Datei/etc/ansible/hostsmit dem Befehlszeileneditor Ihrer Wahl auf Ihrem lokalen Computer oder einem Ansible-Steuerknoten:

sudo nano /etc/ansible/hosts

[.note] #Note: Einige Ansible-Installationen erstellen keine Standardinventardatei. Wenn die Datei in Ihrem System nicht vorhanden ist, können Sie eine neue Datei bei/etc/ansible/hosts erstellen oder einen benutzerdefinierten Inventarpfad mithilfe des Parameters-i angeben, wenn Sie Befehle und Wiedergabebücher ausführen.
#

Die von der Ansible-Installation bereitgestellte Standardinventardatei enthält eine Reihe von Beispielen, die Sie als Referenz für die Einrichtung Ihres Inventars verwenden können. Im folgenden Beispiel wird eine Gruppe mit dem Namenservers mit drei verschiedenen Servern definiert, die jeweils durch einen benutzerdefinierten Alias gekennzeichnet sind:server1,server2 undserver3:

/etc/ansible/hosts

[servers]
server1 ansible_host=203.0.113.111
server2 ansible_host=203.0.113.112
server3 ansible_host=203.0.113.113

[servers:vars]
ansible_python_interpreter=/usr/bin/python3

Die Untergruppeserver:vars legt den Hostparameteransible_python_interpreterfest, der für alle in der Gruppeserversenthaltenen Hosts gültig ist. Dieser Parameter stellt sicher, dass der Remote-Server die ausführbare Python 3-Datei/usr/bin/python3anstelle von/usr/bin/python (Python 2.7) verwendet, die in neueren Ubuntu-Versionen nicht vorhanden ist.

Ersetzen Sie die hervorgehobenen IP-Adressen durch die IP-Adressen Ihrer Server, um die Einrichtung Ihrer Inventardatei abzuschließen. Wenn Sie fertig sind, speichern und schließen Sie die Datei, indem SieCTRL+X, danny drücken, um die Änderungen zu bestätigen, und dannENTER.

Nachdem Ihre Inventardatei fertig ist, können Sie die Konnektivität zu Ihren Knoten testen

Testen der Konnektivität

Nachdem Sie die Inventardatei so eingerichtet haben, dass sie Ihre Server enthält, können Sie prüfen, ob Ansible eine Verbindung zu diesen Servern herstellen und Befehle über SSH ausführen kann. In diesem Handbuch verwenden wir das Konto von Ubunturoot, da dies normalerweise das einzige Konto ist, das standardmäßig auf neu erstellten Servern verfügbar ist. In diesem Playbook wird ein neuer Benutzer ohne Rootberechtigung mit den Berechtigungen vonsudoerstellt, die Sie für nachfolgende Interaktionen mit dem Remoteserver verwenden sollten.

Führen Sie auf Ihrem lokalen Computer oder Ansible Control Node Folgendes aus:

ansible -m ping all -u root

Dieser Befehl verwendet die integriertenpingAnsible module, um einen Konnektivitätstest auf allen Knoten aus Ihrem Standardinventar auszuführen und eine Verbindung alsroot herzustellen. Das Modulping testet:
, wenn auf Hosts zugegriffen werden kann;
, wenn Sie über gültige SSH-Anmeldeinformationen verfügen;
, wenn Hosts Ansible-Module mit Python ausführen können.

Wenn Sie anstelle der schlüsselbasierten Authentifizierungpassword-based authentication verwenden, um eine Verbindung zu Remoteservern herzustellen, sollten Sie den zusätzlichen Parameter-k für den Befehl Ansible angeben, damit Sie zur Eingabe des Kennworts für die Verbindung aufgefordert werden Nutzer.

ansible -m ping all -u root -k

[.note] #Note: Beachten Sie, dass einige Server möglicherweise zusätzliche Sicherheitsmaßnahmen gegen die kennwortbasierte Authentifizierung als Benutzer vonroothaben. In einigen Fällen müssen Sie sich möglicherweise manuell beim Server anmelden um das anfängliche Root-Passwort zu ändern.
#

Sie sollten eine Ausgabe ähnlich der folgenden erhalten:

Outputserver1 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
server2 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
server3 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

Wenn Sie zum ersten Mal über SSH eine Verbindung zu diesen Servern herstellen, werden Sie aufgefordert, die Authentizität der Hosts zu bestätigen, zu denen Sie über Ansible eine Verbindung herstellen. Wenn Sie dazu aufgefordert werden, geben Sieyes ein und drücken Sie zur BestätigungEnter.

Sobald Sie eine "Pong" -Antwort von einem Host erhalten, können Sie Ansible-Befehle und Wiedergabebücher auf diesem Server ausführen.

Was macht dieses Playbook?

Dieses Ansible-Playbook bietet eine Alternative zum manuellen Durchlaufen des inUbuntu 18.04 initial server setup guide und in der Anleitung zusetting up SSH keys on Ubuntu 18.04 beschriebenen Verfahrens.

Wenn Sie dieses Playbook ausführen, werden die folgenden Aktionen ausgeführt:

Die Verwaltungsgruppewheels wird erstellt und dann fürpasswordless sudo konfiguriert.
Innerhalb dieser Gruppe wird ein neuer Administrator mit dem Namen erstellt, der durch die Variablecreate_userangegeben wird.
Ein öffentlicher SSH-Schlüssel wird von dem durch die Variablecopy_local_key definierten Speicherort kopiert und der Dateiauthorized_keys für den im vorherigen Schritt erstellten Benutzer hinzugefügt.
Die kennwortbasierte Authentifizierung ist für den Benutzer vonrootdeaktiviert.
Der lokale Paketindexaptwird aktualisiert und Basispakete, die durch die Variablesys_packagesdefiniert sind, werden installiert.
Die UFW-Firewall ist so konfiguriert, dass nur SSH-Verbindungen zugelassen und andere Anforderungen abgelehnt werden.

Weitere Informationen zu den einzelnen Schritten in diesem Playbook finden Sie in unserenUbuntu 18.04 initial server setup guide.

Sobald das Playbook ausgeführt wurde, können Sie sich mit dem neu erstelltensudo-Konto beim Server anmelden.

Wie man dieses Playbook benutzt

Zunächst laden wir den Inhalt derplaybook auf Ihren Ansible Control Node herunter. Dies kann entweder Ihr lokaler Computer oder ein Remote-Server sein, auf dem Ansible installiert und Ihr Inventar eingerichtet ist.

[.note] # Der Einfachheit halber ist der Inhalt des Spielbuchs auch infurther section of this guide enthalten.
#

Um dieses Playbook von der Befehlszeile herunterzuladen, können Siecurl verwenden:

curl -L https://raw.githubusercontent.com/do-community/ansible-playbooks/master/initial_server_setup/ubuntu1804.yml -o initial_server_setup.yml

Dadurch wird der Inhalt des Playbooks in eine Datei mit dem Nameninitial_server_setup.yml auf Ihrem aktuellen lokalen Pfad heruntergeladen. Sie können den Inhalt des Playbooks überprüfen, indem Sie die Datei mit dem Befehlszeileneditor Ihrer Wahl öffnen:

nano initial_server_setup.yml

Sobald Sie die Playbook-Datei geöffnet haben, sollten Sie einen Abschnitt mit dem Namenvars mit drei verschiedenen Variablen bemerken, die Ihre Aufmerksamkeit erfordern:

create_user: Der Name des Nicht-Root-Benutzerkontos, für das Sudo-Berechtigungen erstellt und erteilt werden sollen. In unserem Beispiel werdensammy verwendet. Sie können jedoch einen beliebigen Benutzernamen verwenden.
copy_local_key: Lokaler Pfad zu einem gültigen öffentlichen SSH-Schlüssel, der als autorisierter Schlüssel für das neue Nicht-Root-Kontosudoeingerichtet werden soll. Der Standardwert zeigt auf den öffentlichen Schlüssel des aktuellen lokalen Benutzers bei~/.ssh/id_rsa.pub.
sys_packages: Eine Liste grundlegender Systempakete, die mit dem Paketmanager-Toolapt installiert werden.

Speichern und schließen Sie die Datei, sobald Sie die Variablen ininitial_server_setup.yml aktualisiert haben.

Sie können dieses Playbook jetzt auf einem oder mehreren Servern ausführen. Die meisten Playbooks sind standardmäßig so konfiguriert, dass sie aufall-Servern aus Ihrem Inventar ausgeführt werden. Wir können das-l-Flag verwenden, um sicherzustellen, dass nur eine Teilmenge von Servern oder ein einzelner Server vom Playbook betroffen ist. Um das Playbook nur aufserver1 auszuführen, können Sie den folgenden Befehl verwenden:

ansible-playbook initial_server_setup.yml  -l server1

Sie erhalten eine Ausgabe ähnlich der folgenden:

Output
PLAY [all] ***************************************************************************************************************************************

TASK [Make sure we have a 'wheel' group] *********************************************************************************************************
changed: [server1]

TASK [Allow 'wheel' group to have passwordless sudo] *********************************************************************************************
changed: [server1]

TASK [Create a new regular user with sudo privileges] ********************************************************************************************
changed: [server1]

TASK [Set authorized key for remote user] ********************************************************************************************************
changed: [server1]

TASK [Disable password authentication for root] **************************************************************************************************
changed: [server1]

TASK [Update apt] ********************************************************************************************************************************
changed: [server1]

TASK [Install required system packages] **********************************************************************************************************
ok: [server1]

TASK [UFW - Allow SSH connections] ***************************************************************************************************************
changed: [server1]

TASK [UFW - Deny all other incoming traffic by default] ******************************************************************************************
changed: [server1]

PLAY RECAP ***************************************************************************************************************************************
server1                    : ok=9    changed=8    unreachable=0    failed=0

Sobald die Ausführung des Playbooks abgeschlossen ist, können Sie sich folgendermaßen beim Server anmelden:

ssh sammy@server_domain_or_IP

Denken Sie daran,sammy durch den durch die Variablecreate_userdefinierten Benutzer undserver_domain_or_IP durch den Hostnamen oder die IP-Adresse Ihres Servers zu ersetzen.

Wenn Sie einen benutzerdefinierten öffentlichen Schlüssel mit der Variablencopy_local_keyfestgelegt haben, müssen Sie einen zusätzlichen Parameter angeben, der den Speicherort des Gegenstücks zum privaten Schlüssel angibt:

ssh sammy@server_domain_or_IP -i ~/.ssh/ansible_controller_key

Nachdem Sie sich beim Server angemeldet haben, können Sie anhand der aktiven Regeln der UFW-Firewall überprüfen, ob diese ordnungsgemäß konfiguriert ist:

sudo ufw status

Sie sollten eine Ausgabe ähnlich der folgenden erhalten:

OutputStatus: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)

Dies bedeutet, dass die UFW-Firewall erfolgreich aktiviert wurde. Da dies die letzte Aufgabe im Playbook war, wird bestätigt, dass das Playbook auf diesem Server vollständig ausgeführt wurde.

Das Playbook Inhalt

Sie finden das erste Playbook zur Servereinrichtung inansible-playbooks repository in DigitalOceanCommunity GitHub organization. Um den Skriptinhalt direkt zu kopieren oder herunterzuladen, klicken Sie oben im Skript auf die SchaltflächeRaw oder aufclick here to view the raw contents directly.

Der vollständige Inhalt ist auch hier zur Vereinfachung enthalten:

initial_server_setup.yml

---
- hosts: all
  remote_user: root
  gather_facts: false
  vars:
    create_user: sammy
    copy_local_key: "{{ lookup('file', lookup('env','HOME') + '/.ssh/id_rsa.pub') }}"
    sys_packages: [ 'curl', 'vim', 'git', 'ufw' ]

  tasks:
    - name: Make sure we have a 'wheel' group
      group:
        name: wheel
        state: present

    - name: Allow 'wheel' group to have passwordless sudo
      lineinfile:
        path: /etc/sudoers
        state: present
        regexp: '^%wheel'
        line: '%wheel ALL=(ALL) NOPASSWD: ALL'
        validate: '/usr/sbin/visudo -cf %s'

    - name: Create a new regular user with sudo privileges
      user:
        name: "{{ create_user }}"
        state: present
        groups: wheel
        append: true
        create_home: true
        shell: /bin/bash

    - name: Set authorized key for remote user
      authorized_key:
        user: "{{ create_user }}"
        state: present
        key: "{{ copy_local_key }}"

    - name: Disable password authentication for root
      lineinfile:
        path: /etc/ssh/sshd_config
        state: present
        regexp: '^#?PermitRootLogin'
        line: 'PermitRootLogin prohibit-password'

    - name: Update apt
      apt: update_cache=yes

    - name: Install required system packages
      apt: name={{ sys_packages }} state=latest

    - name: UFW - Allow SSH connections
      ufw:
        rule: allow
        name: OpenSSH

    - name: UFW - Deny all other incoming traffic by default
      ufw:
        state: enabled
        policy: deny
        direction: incoming

Sie können dieses Wiedergabebuch jederzeit ändern oder neue Aufgaben hinzufügen, um es Ihren individuellen Bedürfnissen in Ihrem eigenen Workflow anzupassen.

Fazit

Durch die Automatisierung der Ersteinrichtung des Servers können Sie Zeit sparen und gleichzeitig sicherstellen, dass Ihre Server einer Standardkonfiguration folgen, die verbessert und an Ihre Bedürfnisse angepasst werden kann. Aufgrund der Verteilung moderner Anwendungen und der Notwendigkeit einer größeren Konsistenz zwischen verschiedenen Staging-Umgebungen wird eine solche Automatisierung zur Notwendigkeit.

In diesem Handbuch wurde gezeigt, wie Ansible zum Automatisieren der ersten Aufgaben verwendet wird, die auf einem neuen Server ausgeführt werden sollen, z. B. das Erstellen eines Nicht-Root-Benutzers mit sudo-Zugriff, das Aktivieren von UFW und das Deaktivieren der Remote-Root-Anmeldung.

Wenn Sie neue Aufgaben in dieses Playbook aufnehmen möchten, um Ihre anfängliche Serverkonfiguration weiter anzupassen, lesen Sie bitte unsere Einführung in AnsibleConfiguration Management 101: Writing Ansible Playbooks.

TOC