Benutzer-Werkzeuge

Webseiten-Werkzeuge


tachtler:archlinux_-_minimal_server_installation_-_mit_ansible

Dies ist eine alte Version des Dokuments!


ArchLinux - Minimal Server Installation - mit Ansible

Die hier verwendete Installationsmethode ist eine Installation von einem ISO-Image/USB-Stick. Es kommt die einzige verfügbare Variante von ArchLinux in der Version 2020.01.01 zum Einsatz.

ist eine Open-Source-Software zur Automatisierung, Orchestrierung und Konfiguration von Serversystemen. Mit Ansible erfolgt die Verwaltung von Servern unter anderem über SSH und erfordert keinerlei zusätzliche Software auf dem zu verwaltenden System. Die Ausgabe erfolgt im JSON-Format und Module können in jeder beliebigen Programmiersprache geschrieben sein. Das System nutzt überwiegend YAML zur Konfiguration von wiederverwendbarer Beschreibungen der Systeme.

Herunterladen

Die Installationsquellen, sprich die ISO-Datei, kann unter nachfolgend aufgelistetem Link heruntergeladen werden:

Als Beispiel-Quelle kann hier nachfolgender Link dienen:

Zum Herunterladen der DVD in das Zielverzeichnis /tmp, kann nachfolgender Befehl genutzt werden:

# wget https://www.archlinux.de/download/iso/2020.01.01/archlinux-2020.01.01-x86_64.iso -P /tmp

USB-Stick erstellen

Das ISO-Image kann mit nachfolgendem Befehl auf einen USB-Stick - hier /dev/sdb als startbereite Abbilddatei (bootable image) erstellt werden:

# dd bs=4M if=/tmp/archlinux-2020.01.01-x86_64.iso of=/dev/sdb && sync

Start: ISO-Image

Nach dem Einschalten des Servers, kann mit der Installation begonnen werden, in dem ein Start von dem sich auf dem USB-Stick befindlichen ArchLinux-ISO-Image in der Version 2020.01.01, durchgeführt wird.

BOOT

Falls dies erfolgreich realisiert werden konnte, sollte in etwa nachfolgender Bildschirm erscheinen:

ArchLinux - ISO - Boot

Durch drücken der [Eingabe|Return]-Taste auf dem Menüpunkt Boot Arch Linux (x86_64) wird ein initialer Start durchgeführt. Nach erfolgreichem Start des „Live“„-Images, sollte nachfolgender Bildschirm erscheinen.

:!: HINWEIS - Eine Anmeldung als Benutzer root ist bereits erfolgt!

Vorbereitungen

Um die folgenden Installationsschritte durchführen zu können, werden nachfolgende Gegebenheiten vorausgesetzt.

  1. Es besteht die Möglichkeit, eine Anbindung an das Internet zu konfigurieren

Tastaturlayout: deutsch

:!: ACHTUNG - Nach dem starten des ISO-Images wird ein US/Englisches-Tastaturlayout verwendet!

Damit alle nachfolgenden Eingabe unter Verwendung eines deutschen Tastaturlayouts durchgeführt werden können, ist nachfolgender Befehl auszuführen:

root@archiso ~ # loadkeys de-latin1-nodeadkeys

Der Buchstabe [y] befindet sich auf der englischen Tastatur auf der Taste [z].
Das Zeichen [-] befindet sich auf der englischen Tastatur auf der Taste [ß].

:!: HINWEIS - Anschließend sollte ein deutsches Tastaturlayout geladen sein!

Passwort: root

Damit später nachfolgende Konfigurationen durchgeführt werden können, soll eine Verbindung via SSH hergestellt werden.

Dazu ist es erforderlich, das der Benutzer root im „Live“-System ein Passwort besitzt, was mit nachfolgendem Befehl gesetzt werden kann:

root@archiso ~ # passwd
New password
Retype new password:
passwd: password updated successfully

Das Passwort ist in der shell hinter New password: einzugeben und mit der [Return/Enter]-Taste zu bestätigen. Anschließend ist der shell hinter Retype new password: das gleiche Passwort erneut einzugeben und ebenfalls mit der [Return/Enter]-Taste zu bestätigen.

Netzwerkkarte: manuelle Konfiguration

Nachfolgende Befehle sollen eine Verbindung mit einem bestehenden Netzwerk mit Internet-Zugang herstellen.

Zuerst sollte die Bezeichnung der Netzwerkkarte mit nachfolgendem Befehl ermittelt werden:

root@archiso ~ # ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: ens3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
    link/ether 52:54:00:00:de:ad brd ff:ff:ff:ff:ff:ff
    inet6 fe80::baa6:bfbf:5fbd:1f6c/64 scope link 
       valid_lft forever preferred_lft forever

Die Bezeichnung der Netzwerkkarte in oben gezeigtem Beispiel lautet aktuell: ens3. In der gleichen Zeile ist auch zu sehen, das die Karte bereits den Status UP hat, also aktiv und nutzbar ist.

:!: HINWEIS - Falls die Netzwerkkarte nicht UP und damit aktiv sein sollte, kann mit nachfolgendem Befehl, die Karte mit der Bezeichnung ens3 aktiviert, sprich in den Status UP versetzt werden:

root@archiso ~ # ip link set up dev ens3

Die Zuweisung einer IPv4-Netzwerkadresse kann mit nachfolgendem Befehl durchgeführt werden:

root@archiso ~ # ip addr add 192.168.1.250/24 dev ens3

Ein Überprüfung, ob die IPv4-Netzwerkadresse für die Netzwerkkarte mit der Bezeichnung ens3 gesetzt wurde, kann mit nachfolgendem Befehl erfolgen:

root@archiso ~ # ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: ens3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
    link/ether 52:54:00:00:de:ad brd ff:ff:ff:ff:ff:ff
    inet 192.168.1.250/24 scope global ens3
       valid_lft forever preferred_lft forever
    inet6 fe80::baa6:bfbf:5fbd:1f6c/64 scope link 
       valid_lft forever preferred_lft forever

Damit nun eine Verbindung nicht nur in das bereits aktuelle erreichbare Netzwerk möglich ist, sondern auch eine Standardroute - default-Route den Weg in Richtung Internet finden kann, ist die Konfiguration einer default-Route erforderlich, was mit nachfolgendem Befehl durchgeführt werden kann:

root@archiso ~ # ip route add default via 192.168.1.10

Eine Überprüfung mit nachfolgendem Befehl zeigt nun die aktuellen Routen, inklusive der default-Route an, welche auch in das Internet führen sollte:

root@archiso ~ # ip ro
default via 192.168.1.10 dev ens3
192.168.1.0/24 dev ens3 proto kernel scope link src 192.168.1.250

Ob die Verbindung zum Internet hergestellt wurde, kann mit nachfolgendem Test durch den nachfolgenden Befehl durchgeführt werden. Drei ping in Richtung eines Namensservers (DNS) von Google mit der IP-Adresse: 8.8.8.8, sollte nun möglich sein und eine Rückmeldung wie nachfolgende zurück liefern:

root@archiso ~ # ping -c3 8.8.8.8
PING 8.8.8.8 (8.8.8.8) 56(84) bytes of data.
64 bytes from 8.8.8.8 icmp_seq=1 ttl=57 time=82.4 ms
64 bytes from 8.8.8.8 icmp_seq=2 ttl=57 time=95.3 ms
64 bytes from 8.8.8.8 icmp_seq=3 ttl=57 time=113 ms

--- 8.8.8.8 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2004ms
rtt min/avg/max/mdev = 82.381/97.030/113.418/12.730 ms

Namensauflösung: /etc/resolv.conf

Damit nicht nur der Netzwerk technische Zugriff auf das Internet möglich ist, sondern auch eine Namensauflösung wie z.B. Google zu einer IP-Adresse möglich ist, ist es erforderlich, dass ein Namensserver konfiguriert wird, welche im Netzwerk oder aus dem Netzwerk erreichbar ist. Dies kann durch Ausführen des nachfolgenden Befehls durchgeführt werden:

root@archiso ~ # echo nameserver 192.168.1.20 >> /etc/resolv.conf

:!: HINWEIS - Falls kein eigener Namensserver zur Verfügung stehen sollte, wäre auch ein extern erreichbarer Nameserver wie der von Google ein ggf. kurzfristige Option, was durch Ausführung von nachfolgenden Befehlen ermöglicht werden könnte:

root@archiso ~ # echo nameserver 8.8.8.8 >> /etc/resolv.conf
root@archiso ~ # echo nameserver 8.8.4.4 >> /etc/resolv.conf

Mit nachfolgendem Befehl kann überprüft werden, ob die Ergänzung der Konfiguratiosndatei /etc/resolv.conf erfolgreich war:

root@archiso ~ # cat /etc/resolv.conf
# Resolver configuration file.
# See resolv.conf(5) for details.
nameserver 192.168.1.20

Ob die Namensauflösung Richtung Internet hergestellt wurde, kann mit nachfolgendem Test durch den nachfolgenden Befehl durchgeführt werden. Drei ping in Richtung von Google, sollte nun möglich sein und eine Rückmeldung wie nachfolgende zurück liefern:

root@archiso ~ # ping -c3 google.de
PING google.de (172.217.23.35) 56(84) bytes of data.
64 bytes from lhr35s02-in-f3.1e100.net (172.217.23.35): icmp_seq=1 ttl=57 time=23.5 ms
64 bytes from lhr35s02-in-f3.1e100.net (172.217.23.35): icmp_seq=1 ttl=57 time=25.0 ms
64 bytes from lhr35s02-in-f3.1e100.net (172.217.23.35): icmp_seq=1 ttl=57 time=22.9 ms

--- google.de ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2619ms
rtt min/avg/max/mdev = 22.853/23.799/25.031/0.911 ms

SSH-Dienst: starten

Damit eine Verbindung zum Server, welcher via „Live“-ISO-Image gestartet wurde, hergestellt werden kann, muss der bereits entsprechend vorkonfigurierte SSH-Dienst/Daemon mit nachfolgendem Befehl gestartet werden:

root@archiso ~ # systemctl start sshd.service

Eine Überprüfung ob der SSH-Dienst/Daemon auch ordnungsgemäß gestartet wurde, kann durch ausführen des nachfolgenden Befehls durchgeführt werden und sollte eine Ausgabe in etwa wie nachfolgende zur Folge haben:

root@archiso ~ # systemctl status sshd.service
● sshd.service - OpenSSH Daemon
   Loaded: loaded (/usr/lib/systemd/system/sshd.service; disabled; vendor prese>
   Active: active (running) since Sun 2020-01-10 08:28:08 UTC; 8s ago
 Main PID: 822 (sshd)
    Tasks: 1 (limit: 2332)
   Memory: 2.0M
   CGroup: /system.slice/sshd.service
           └─822 /usr/bin/sshd -D

Jan 10 08:28:08 archiso systemd[1]: Started OpenSSH Daemon.
Jan 10 08:28:08 archiso sshd[882]: Server listening on 0.0.0.0 port 22.
Jan 10 08:28:08 archiso sshd[882]: Server listening on :: port 22.

Verbindung: SSH-Login (root)

Jetzt kann eine erste Verbindung als Benutzer root via SSH-Login auf dem Server, welcher via „Live“-ISO-Image gestartet wurde, hergestellt werden. Nachfolgender Befehl soll dazu auf einer lokalen Workstation, nicht auf dem Server verwendet werden:

$ ssh root@192.168.1.250
The authenticity of host '192.168.1.250 (192.168.1.250)' can't be established.
ECDSA key fingerprint is SHA256:AizXWHnKF2FQHZxGpuPW8Wk/TG/NZYuzNbwLxmmGCOw.
ECDSA key fingerprint is MD5:a0:b5:24:1a:f5:84:81:14:b3:ec:2f:7c:3a:dd:1a:7f.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '192.168.1.250' (ECDSA) to the list of known hosts.
root@192.168.1.250's password: 
Last login: Fri Jan 10 06:50:29 2020
root@archiso ~ #

Ansible

Die Nutzung von Ansible basiert auf der nachfolgenden Installation, welche unter dem folgenden internen Link nachvollzogen werden kann:

Ab hier werden root-Rechte zur Ausführung der nachfolgenden Befehle benötigt. Um der Benutzer root zu werden, geben Sie bitte nachfolgenden Befehl ein:

$ su -
Password: 

/home/ansible/ansible/inventories/production/hosts

Damit die Installation auf jeweils nur einem zu installierendem Host bzw. Server statt finden kann, ist nachfolgende Anpassung der hosts-Konfigurationsdatei, hier

  • /home/ansible/ansible/inventories/production/hosts

von Ansible mindestens erforderlich, wie nachfolgende Beschreibung zeigt:

VORHER:

# BEGIN ANSIBLE MANAGED BLOCK
[ansible]
192.168.1.250
# END ANSIBLE MANAGED BLOCK

NACHHER:

[ansible]
192.168.1.250
 
[install]
192.168.1.10

* Wobei hier die IP-Adresse: 192.168.1.10 für den neu zu installierenden Server steht!

/home/ansible/ansible/archlinux-install.yml

Nachfolgende Konfiguration soll ein Playbook erstellen, um ArchLinux wie unter nachfolgendem internen Link zu installieren:

Das Playbook mit dem ArchLinux konfiguriert werden soll, soll in nachfolgendem Verzeichnis mit ebenfalls nachfolgendem Namen durch folgenden Befehl neu erstellt werden:

# vim /home/ansible/ansible/archlinux-install.yml

:!: WICHTIG - Die Variablen im Bereich - vars: - sollten den individuellen Gegebenheiten ggf. angepasst werden!

Nachfolgend das Playbook.

--- ### ArchLinux installation
  # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation
- hosts: install
 
  #
  ##############################################################################
  # >>> Please edit following lines for personal settings and custom usages. ! #
  ##############################################################################
  #

  vars:
    parted_device: vda
    parted_device_partition:
      - name: "partition1"
        number: 1
        flags: []
        start: 0%
        end: 1025MiB
      - name: "partition2"
        number: 2
        flags: [ lvm ]
        start: 1025MiB
        end: 100%
    parted_device_pv: 2
    parted_device_vg: archlinux
    parted_device_swap:
      - name: "swap"
        size: 2048
        type: "swap"
    parted_device_boot:
      - name: "boot"
        size: 1024
        type: "ext4"
        path: "/mnt/boot"
    # First "logical volume" MUST be root!
    parted_device_lv:
      - name: "root"
        size: 10240
        type: "ext4"
        path: "/mnt"
      - name: "home"
        size: 1024
        type: "ext4"
        path: "/mnt/home"
      - name: "var"
        size: 3072
        type: "ext4"
        path: "/mnt/var"
      - name: "var_log"
        size: 2048
        type: "ext4"
        path: "/mnt/var/log"
    # System environment setup
    mnt_hostname: archlinux
    mnt_lang: en_US.UTF-8
    # systemd-networkd.service configuration first interface
    mnt_ip: 192.168.1.11/24
    mnt_gateway: 192.168.1.1
    mnt_dns: 192.168.1.1
 
    #
    ##############################################################################
    # >>> Normaly there is no need to change anything below this comment line. ! #
    ##############################################################################
    #

  tasks:
    - name: Read device information from disk
      parted:
        device: "/dev/{{ parted_device }}"
        unit: MiB
      register: device_parted
 
      # 
      # Partitionierung fdisk
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#partitionierungfdisk
      #
    - name: Create partitions
      parted:
        device: "/dev/{{ parted_device }}"
        number: "{{ item.number }}"
        flags: "{{ item.flags }}"
        state: present
        part_start: "{{ item.start }}" 
        part_end: "{{ item.end }}"
      with_items: "{{ parted_device_partition }}"
 
      # 
      # LVM, Dateisysteme formatieren, Partitonen einhaengen
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#lvm
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#dateisysteme_formatieren
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#partitonen_einhaengen
      # 
    - name: Create a volume group on partition LVM 
      lvg:
        vg: "{{ parted_device_vg }}"
        pvs: "/dev/{{ parted_device }}{{ parted_device_pv }}"

    - name: Create swap volume
      lvol:
        vg: "{{ parted_device_vg }}"
        lv: "{{ item.name }}" 
        size: "{{ item.size }}"
      with_items: "{{ parted_device_swap }}"

    - name: Create logical volumes
      lvol:
        vg: "{{ parted_device_vg }}"
        lv: "{{ item.name }}" 
        size: "{{ item.size }}"
      with_items: "{{ parted_device_lv }}"

    - name: Make directory for mount point boot
      file:
        path: "{{ item.path }}"
        state: directory
      with_items: "{{ parted_device_boot }}"

    - name: Create a filesystem on each logical volume
      filesystem:
        fstype: "{{ item.type }}" 
        dev: "/dev/mapper/{{ parted_device_vg }}-{{ item.name }}"
      with_items: "{{ parted_device_lv }}"

    - name: Make directorys for mount points
      file:
        path: "{{ item.path }}"
        state: directory
      with_items: "{{ parted_device_lv }}"

    - name: Mount each logical volume
      mount:
        src: "/dev/mapper/{{ parted_device_vg }}-{{ item.name }}"
        path: "{{ item.path }}"
        fstype: "{{ item.type }}"
        state: mounted
      with_items: "{{ parted_device_lv }}"

    - name: Make directorys for nested mount points
      file:
        path: "{{ item.path }}"
        state: directory
      with_items: "{{ parted_device_lv }}"

    - name: Mount each nested logical volume
      mount:
        src: "/dev/mapper/{{ parted_device_vg }}-{{ item.name }}"
        path: "{{ item.path }}"
        fstype: "{{ item.type }}"
        state: mounted
      with_items: "{{ parted_device_lv }}"

    - name: Create a filesystem on boot volume
      filesystem:
        fstype: "{{ item.type }}" 
        dev: "/dev/{{ parted_device }}1"
      with_items: "{{ parted_device_boot }}"

    - name: Mount boot logical volume
      mount:
        src: "/dev/{{ parted_device }}1"
        path: "{{ item.path }}"
        fstype: "{{ item.type }}"
        state: mounted
      with_items: "{{ parted_device_boot }}"

    - name: Create a filesystem on swap volume
      filesystem:
        fstype: "{{ item.type }}" 
        dev: "/dev/mapper/{{ parted_device_vg }}-{{ item.name }}"
      with_items: "{{ parted_device_swap }}"

    - name: Swapon swap device
      command: "swapon /dev/mapper/{{ parted_device_vg }}-{{ item.name }}"
      with_items: "{{ parted_device_swap }}"
 
      # 
      # Installation Basissystem
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#installationbasissystem
      #
 
      # 
      # /etc/pacman.d/mirrorlist
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#etc_pacmand_mirrorlist
      #
    - name: Check if file NOT exists - /etc/pacman.d/mirrorlist.orig
      stat: 
        path: /etc/pacman.d/mirrorlist.orig
      register: mirrorlist_orig
 
    - name: Copy /etc/pacman.d/mirrorlist to /etc/pacman.d/mirrorlist.orig
      copy:
        src: /etc/pacman.d/mirrorlist
        dest: /etc/pacman.d/mirrorlist.orig
        remote_src: yes
      when: mirrorlist_orig.stat.exists == false
     
    - name: Generate German Mirrorlist for pacman
      shell: grep -E -A 1 ".*Germany.*$" /etc/pacman.d/mirrorlist.orig | sed "/--/d" > /etc/pacman.d/mirrorlist
 
      # 
      # Basissystem /mnt
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#basissystemmnt
      #
    - name: Generate Basissystem with pacstrap (This may take some time!)
      command: pacstrap /mnt base base-devel linux-lts linux-firmware lvm2 openssh sshpass vi vim
      register: pacstrap

    - debug:
        msg: >-
          { "stdout": {{ pacstrap.stdout_lines }},
            "stderr": {{ pacstrap.stderr.splitlines() }} }
 
      # 
      # Systemkonfiguration /mnt
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#systemkonfigurationmnt
      #
 
      # 
      # /etc/fstab erstellen
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#etc_fstab_erstellen
      #
    - name: Generate /etc/fstab
      shell: genfstab -Up /mnt > /mnt/etc/fstab
 
      # 
      # /etc/hostname
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#etc_hostname
      #
    - name: chroot - Set /etc/hostname
      shell: 
        cmd: |
          arch-chroot /mnt <<EOF
          echo {{ mnt_hostname }} > /etc/hostname
          EOF
      args:
        executable: /bin/bash
 
      # 
      # /etc/locale.conf
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#etc_localeconf
      #
    - name: chroot - Set /etc/locale.conf 
      shell: 
        cmd: |
          arch-chroot /mnt <<EOF
          echo LANG={{ mnt_lang }} > /etc/locale.conf
          EOF
      args:
        executable: /bin/bash
 
      # 
      # /etc/locale.gen
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#etc_localegen
      #
    - name: chroot - Changes to /etc/locale.gen
      shell: 
        cmd: |
          arch-chroot /mnt <<EOF
          cp -a /etc/locale.gen /etc/locale.gen.orig
          sed -i '/#en_US*/s/^#//g' /etc/locale.gen
          locale-gen
          EOF
      args:
        executable: /bin/bash
      register: localegen 

    - debug:
        msg: >-
          { "stdout": {{ localegen.stdout_lines }},
            "stderr": {{ localegen.stderr.splitlines() }} }
 
      # 
      # /etc/vconsole.conf
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#etc_vconsoleconf
      #
    - name: chroot - Set /etc/vconsole.conf 
      shell: 
        cmd: |
          arch-chroot /mnt <<EOF
          echo KEYMAP=de-latin1-nodeadkeys > /etc/vconsole.conf
          echo FONT=lat9w-16 >> /etc/vconsole.conf
          EOF
      args:
        executable: /bin/bash
 
      # 
      # /etc/localtime
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#etc_localtime
      #
    - name: chroot - Set /etc/localtime
      shell: 
        cmd: |
          arch-chroot /mnt <<EOF
          ln -sf /usr/share/zoneinfo/Europe/Berlin /etc/localtime
          EOF
      args:
        executable: /bin/bash
 
      # 
      # /etc/hosts
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#etc_hosts
      #
    - name: chroot - Set /etc/hosts
      shell: 
        cmd: |
          arch-chroot /mnt <<EOF
          cat > /etc/hosts <<INEOF
          #<ip-address> <hostname.domain.tld>   <hostname>
          127.0.0.1     localhost.localdomain   localhost
          ::1           localhost.localdomain   localhost
          INEOF
          EOF
      args:
        executable: /bin/bash
 
      # 
      # /etc/mkinitcpio.conf
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#etc_mkinitcpioconf
      #
    - name: chroot - Set /etc/mkinitcpio.conf
      shell: 
        cmd: |
          arch-chroot /mnt <<EOF
          cp -a /etc/mkinitcpio.conf /etc/mkinitcpio.conf.orig
          sed -i 's/block\ filesystem/block\ lvm2\ filesystem/g' /etc/mkinitcpio.conf
          mkinitcpio -p linux-lts
          EOF
      args:
        executable: /bin/bash
      register: mkinitcpio 

    - debug:
        msg: >-
          { "stdout": {{ mkinitcpio.stdout_lines }},
            "stderr": {{ mkinitcpio.stderr.splitlines() }} }
 
      # 
      # Bootloader GRUB
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#bootloadergrub
      #
    - name: chroot - Install and configure Bootloader - GRUB
      shell: 
        cmd: |
          arch-chroot /mnt <<EOF
          pacman -S grub --noconfirm
          grub-install "/dev/{{ parted_device }}"
          sed -i 's/quiet/net\.ifnames=0/g' /etc/default/grub
          grub-mkconfig -o /boot/grub/grub.cfg 
          EOF
      args:
        executable: /bin/bash
      register: grub

    - debug:
        msg: >-
          { "stdout": {{ grub.stdout_lines }},
            "stderr": {{ grub.stderr.splitlines() }} }
 
      # 
      # passwd root
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#passwortroot1
      #
    - name: chroot - Set a default passwd for the root user (toor)
      shell: 
        cmd: |
          arch-chroot /mnt <<EOF
          echo "root:toor" | chpasswd
          EOF
      args:
        executable: /bin/bash
 
      #
      # Netzwerk systemd
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#netzwerksystemd
      #
    - name: Create /mnt/etc/systemd/networkd/eth0.network
      shell: 
        cmd: |
          cat > /mnt/etc/systemd/network/eth0.network <<EOF
          [Match]
          Name=eth0
 
          [Network]
          Address={{ mnt_ip }}
          Gateway={{ mnt_gateway }}
          DNS={{ mnt_dns }}
          EOF
      args:
        executable: /bin/bash

    - name: chroot - Enable systemd-networkd.service
      shell: 
        cmd: |
          arch-chroot /mnt <<EOF
          systemctl enable systemd-networkd.service
          EOF
      args:
        executable: /bin/bash

    - name: Update /mnt/etc/resolv.conf
      shell: 
        cmd: |
          cat >> /mnt/etc/resolv.conf <<EOF
          nameserver {{ mnt_dns }}
          EOF
      args:
        executable: /bin/bash
 
      #
      # SSH-Dienst/Deamon einrichten
      # https://dokuwiki.tachtler.net/doku.php?id=tachtler:archlinux_-_minimal_server_installation#ssh-dienst_deamon_einrichten
      #
    - name: Check if file NOT exists - /mnt/etc/sshd/sshd.config.orig
      stat: 
        path: /mnt//etc/ssh/sshd_config.orig
      register: sshd_config_orig
 
    - name: Copy /mnt/etc/sshd/sshd_config to /etc/ssh/sshd_config.orig
      copy:
        src: /mnt/etc/ssh/sshd_config
        dest: /mnt/etc/ssh/sshd_config.orig
        remote_src: yes
      when: sshd_config_orig.stat.exists == false

    - name: Change configuration of /mnt/etc/ssh/sshd_config
      lineinfile:
        line: "{{ item.line }}"
        path: "/mnt/etc/ssh/sshd_config"
        regexp: "{{ item.regexp }}"
        state: present 
      with_items:
        - { regexp: "^#PermitRootLogin\ prohibit-password", line: "# Tachtler\n# default: #PermitRootLogin prohibit-password\nPermitRootLogin yes" }
        - { regexp: "^#PasswordAuthentication yes", line: "# Tachtler\n# default: #PasswordAuthentication yes\nPasswordAuthentication yes" }

    - name: chroot - Enable sshd.service
      shell: 
        cmd: |
          arch-chroot /mnt <<EOF
          systemctl enable sshd.service
          EOF
      args:
        executable: /bin/bash

Playbook

Benutzer: ansible

Zuerst muss auf den Benutzer gewechselt werden, welcher das Playbook ausführen soll. Hier wäre dies der Benutzer ansible aus der vorangegangenen Ansible-Installation, wie unter nachfolgendem internen Link beschrieben:

Nachfolgender Befehl fürt den Wechsel auf den Benutzer, hier, ansible aus:

# su - ansible

Verbindungstest

Bevor das eigentliche Playbook ausgeführt werden kann, muss ein Verbindungstest ausgeführt werden, um

  1. die Verbindung zu testen
  2. den Host-Key, für die SSH-Verbindung in der ~/.ssh/known_hosts zu hinterlegen

was mit nachfolgendem Befehl durchgeführt werden kann:

$ ssh root@192.168.1.10
The authenticity of host '192.168.1.10 (192.168.1.10)' can't be established.
ECDSA key fingerprint is SHA256:Lwt+NpXV/fd/iS4ea9TY/LJYfOVBoQjBGBvyite/P/I.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '192.168.1.10' (ECDSA) to the list of known hosts.
root@192.168.1.10's password: 
Last login: Sat Feb  1 05:46:53 2020
root@archiso ~ #

* Wobei hier die IP-Adresse: 192.168.1.10 für den neu zu installierenden Server steht!

Zum Verlassen des Hosts, kann hier der nachfolgende Befehl genutzt werden:

root@archiso ~ # exit
Connection to 192.168.1.10 closed.

Playbook überprüfen

Nachfolgender Befehl führt eine detaillierte Überprüfung des angegeben Playbook durch:

$ ansible-playbook --syntax-check /home/ansible/ansible/archlinux-install.yml

playbook: /home/ansible/ansible/archlinux-install.yml

Playbook ausführen

Nachfolgender Befehl für das Playbook, welches unter /home/ansible/ansible/archlinux-install.yml gespeichert sein sollte aus:

:!: WICHTIG - Hier MUSS der Benutzer root und dessen Passwort auf dem neu zu installierendem Server verwendet werden!

$ ansible-playbook -u root --ask-pass /home/ansible/ansible/archlinux-install.yml
$ ansible-playbook -u root --ask-pass /home/ansible/ansible/archlinux-install.yml

Neustart

Zum Neustart des Servers, muss eine Verbindung via SSH mit dem neu erstellten Server als Benutzer root aufgebaut werden, was mit nachfolgendem Befehl realisiert werden kann:

$ ssh root@192.168.1.10
root@192.168.1.10's password: 
Last login: Sat Feb  1 06:54:29 2020 from 192.168.1.250

Der abschließende Neustart wird dann mit nachfolgendem Befehl durchgeführt:

root@archiso ~ # reboot

Nach erfolgreichem Neustart, sollte nachfolgender „Boot-Screen“ beim Start des Servers erscheinen, wie die folgende Bildschirmkopie zeigt:

ArchLinux - Boot - Screen

Nach erfolgreichem „Booten“ des Servers, sollte eine Anmeldung als Benutzer root nun möglich sein, wie ebenfalls die folgende Bildschirmkopie zeigt:

ArchLinux - Login - Screen

Erste Anmeldung

Nach dem erfolgreichen ersten Start des Servers sind die folgenden Gegebenheiten zu beachten:

:!: ACHTUNG - Es gibt außer dem Benutzer root, KEINE Benutzer die sich anmelden können!

Jetzt kann eine erste Verbindung als Benutzer root via SSH-Login auf den Server hergestellt werden. Nachfolgender Befehl soll dazu auf einer lokalen Workstation, nicht auf dem Server verwendet werden:

Benuzter: root
Passwort: toor

$ ssh root@192.168.1.11
The authenticity of host '192.168.1.11 (192.168.122.251)' can't be established.
ECDSA key fingerprint is SHA256:XXEA3rmz31DO2+fhLzlkXadg6XZ3k/8wKANKVt0Zygo.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '192.168.1.11' (ECDSA) to the list of known hosts.
root@192.168.1.11's password: 
[root@archlinux ~]#

* Wobei die IP-Adresse: 192.168.1.11 im Playbook unter der Variable mnt_ip festgelegt wurde!

:!: WICHTIG - Bitte das Passwort für den Benutzer root noch ändern !!!

Diese Website verwendet Cookies. Durch die Nutzung der Website stimmen Sie dem Speichern von Cookies auf Ihrem Computer zu. Außerdem bestätigen Sie, dass Sie unsere Datenschutzbestimmungen gelesen und verstanden haben. Wenn Sie nicht einverstanden sind, verlassen Sie die Website.Weitere Information
tachtler/archlinux_-_minimal_server_installation_-_mit_ansible.1580627326.txt.gz · Zuletzt geändert: 2020/02/02 08:08 von klaus