So installierst du FreeIPA Server mit Docker unter Debian 11

FreeIPA ist eine Open-Source-Identitätsmanagementlösung für Linux/Unix-Betriebssysteme. Es ist ein Vorläuferprojekt des RedHat Identity Management Systems, das Authentifizierungs- und Autorisierungslösungen für Linux/Unix-Systeme bietet.

FreeIPA baut auf mehreren Komponenten auf, darunter der Directory Server, DNS, Kerberos, PKI, Certmonger, NTP Server, Webadministrations-UI, etc. Es bietet eine zentrale Quelle für Benutzeranmeldedaten und Zugangskontrolle. Mit FreeIPA können Administratoren die Identität in einer zentralisierten Umgebung einfach verwalten und die Benutzerüberwachung, Authentifizierung und Zugangskontrolle übernehmen.

In dieser Anleitung wirst du den FreeIPA-Server auf einem Debian 11-Rechner über Docker installieren und einrichten. Du installierst Docker CE (Community Edition), erstellst ein FreeIPA Server Docker-Image, installierst den FreeIPA Server und lernst dann die grundlegende Verwaltung des FreeIPA Servers. Außerdem lernst du, wie du einen Linux-Client-Rechner als FreeIPA-Client zum FreeIPA-Server hinzufügst, der als Docker-Container läuft.

Voraussetzungen

Für diese Anleitung benötigst du einen Linux-Server mit Debian 11 und mindestens 4 GB Arbeitsspeicher. Außerdem brauchst du einen Root-Benutzer oder einen Nicht-Root-Benutzer mit Administrator-Rechten. Für den Client kannst du jede beliebige Linux-Distribution verwenden, aber für dieses Beispiel wirst du Ubuntu als FreeIPA-Client-Maschine verwenden.

FQDN und Zeitzone einrichten

Bevor du Docker und FreeIPA installierst, musst du sicherstellen, dass du den richtigen FQDN (Fully Qualified Domain Name), die richtige „/etc/hosts“ -Datei und auch die richtige Zeitzone hast. In diesem ersten Schritt wirst du den fqdn, die /etc.hosts-Datei und die Zeitzone auf deinem Debian-Server einrichten.

Zuerst richtest du den fqdn deines FreeIPA-Servers ein, indem du den folgenden Befehl eingibst.

sudo hostnamectl set-hostname ipa.hwdomain.lan

Öffne nun die Datei„/etc/hosts“ mit dem folgenden nano-Editor-Befehl.

sudo nano /etc/hosts

Füge die Details der IP-Adresse, des fqdn und den Hostnamen deines Systems hinzu.

192.168.5.10 ipa.hwdomain.lan  ipa

Speichere und schließe die Datei, wenn du fertig bist.

Gib nun den folgenden Befehl ein, um den fqdn deines Systems zu überprüfen und sicherzustellen, dass der fqdn auf die richtige interne IP-Adresse zeigt.

sudo hostname -f
sudo ping -c3 ipa.hwdomain.lan

Als Nächstes gibst du den folgenden Befehl ein, um die Zeitzone deines Systems einzustellen. Achte darauf, dass du die Zeitzone im folgenden Befehl mit der Zeitzone deines Servers abgleichst.

sudo timedatectl set-timezone Europe/Stockholm

Gib den folgenden Befehl ein, um die Ortszeit für dein System einzurichten.

sudo unlink /etc/localtime
sudo ln -s /usr/share/timezone/Europe/Stockholm /etc/localtime

Gehe nun zum nächsten Schritt über, um die Installation von Docker CE zu starten.

Installation von Docker CE

FreeIPA Server kann auf viele Arten installiert werden. Für Debian-basierte Distributionen kannst du Docker verwenden. In diesem Abschnitt wirst du Docker CE (Community Edition) über das offizielle Docker-Repository installieren und deinen Benutzer so einrichten, dass er Docker-Container ausführen und starten kann.

Gib zunächst den folgenden apt-Befehl ein, um die grundlegenden Abhängigkeiten zu installieren. Wenn du dazu aufgefordert wirst, bestätige mit y und drücke ENTER, um fortzufahren.

sudo apt install ca-certificates \
    curl \
    gnupg \
    git \
    lsb-release

Als Nächstes fügst du den GPG-Schlüssel des Docker CE-Repositorys hinzu und lädst ihn herunter.

sudo mkdir -m 0755 -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Sobald der GPG-Schlüssel hinzugefügt ist, gibst du den folgenden Befehl ein, um das Docker CE Repository hinzuzufügen.

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Führe nun den Befehl„apt update“ aus, um deinen Debian-Paketindex zu aktualisieren und aufzufrischen.

sudo apt update

Installiere dann die Docker CE Pakete, indem du den Befehl „apt install“ eingibst. Bestätige mit y, wenn du dazu aufgefordert wirst, und drücke ENTER, um fortzufahren.

sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Wenn Docker CE installiert ist, läuft es auch automatisch und ist aktiviert. Führe den Befehl„systemctl“ aus, um den Docker-Dienst zu überprüfen.

sudo systemctl is-enabled docker
sudo systemctl status docker

Du solltest die Ausgabe„enabled“ sehen, was bedeutet, dass der Docker-Dienst beim Systemstart automatisch ausgeführt wird. Und die Ausgabe„active (running)“ bestätigt, dass der aktuelle Docker-Dienst läuft.

Wenn du deine Docker-Anwendung über einen Nicht-Root-Benutzer ausführen willst, musst du deinen Benutzer zur Gruppe „Docker“ hinzufügen. Gib den folgenden Befehl ein, um deinen Benutzer zur Gruppe„docker“ hinzuzufügen. In diesem Beispiel fügst du einen Benutzer„bob“ zur Gruppe„docker“ hinzu.

sudo usermod -aG docker bob

Melde dich nun als Benutzer„bob“ an und gib den unten stehenden Docker-Befehl ein, um den„hello-world„-Container auszuführen. Wenn du erfolgreich warst, solltest du die Willkommensnachricht des Containers auf deinem Terminalbildschirm sehen.

su - bob
docker run hello-world

Damit hast du den Docker-Container als Nicht-Root-Benutzer mit dem Benutzernamen„bob“ erfolgreich ausgeführt und gestartet. Im weiteren Verlauf dieses Leitfadens wirst du die Befehle mit dem Benutzer„bob“ ausführen.

FreeIPA-Docker-Image erstellen

In diesem Abschnitt wirst du das Docker-Image für den FreeIPA-Server erstellen. Dazu kannst du das FreeIPA-Container-Repository ganz einfach von der offiziellen FreeIPA-GitHub-Seite herunterladen. Danach kannst du eine beliebige Linux-Distribution für das Basis-Image wählen.

Als erstes installierst du„git“ auf deinem Debian-Server mit dem unten stehenden apt-Befehl. Wenn du dazu aufgefordert wirst, gib zur Bestätigung y ein und drücke ENTER.

sudo apt install git

Führe nun den folgenden git-Befehl aus, um das freeipa-container Repository auf dein System herunterzuladen. Verschiebe dann dein Arbeitsverzeichnis dorthin.

git clone https://github.com/freeipa/freeipa-container.git
cd freeipa-container

Führe nun den Befehl„ls“ aus, um die Liste der Dateien und Verzeichnisse im Repository „freeipa-container“ zu überprüfen. Du solltest mehrere Dockerdateien sehen, die du verwenden kannst, um den FreeIPA-Server auf deinem Debian-System einzurichten.

ls

Als Nächstes gibst du den folgenden Befehl ein, um ein neues FreeIPA-Server-Docker-Image zu erstellen. In diesem Beispiel erstellst du ein FreeIPA-Server-Docker-Image auf Basis von„AlmaLinux 9“ und nennst es„freeipa-almalinux9„.

docker build -t freeipa-almalinux9 -f  Dockerfile.almalinux-9 .

Sobald der Befehl„docker build“ ausgeführt wird, solltest du den Erstellungsprozess des Docker-Images für den FreeIPA-Server sehen.

Wenn der Prozess abgeschlossen ist, solltest du eine Ausgabe wie„naming to …/…/freeipa-almalinux9“ sehen.

Führe den folgenden Befehl aus, um die Liste der Docker-Images zu überprüfen, die auf deinem System verfügbar sind. Du solltest sehen, dass das Docker-Image mit dem Namen„freeipa-almalinux9“ erstellt wurde und auf deinem System verfügbar ist.

docker images

Nachdem du das FreeIPA-Docker-Image erstellt hast, kannst du den FreeIPA-Server und die Konfiguration über Docker installieren.

FreeIPA Server Container erstellen

In diesem Abschnitt installierst und konfigurierst du den FreeIPA-Server über einen Docker-Container. Du startest einen neuen Container mit dem Basis-Image„freeipa-almalinux9„, das du erstellt hast, und beginnst dann mit der Konfiguration des FreeIPA-Servers. Sobald die Konfigurationen abgeschlossen sind, richtest du als Nächstes die Port-Zuordnung des FreeIPA-Server-Containers auf dem Docker-Host-Rechner ein.

Gib zunächst den folgenden Befehl ein, um ein neues Datenverzeichnis „/var/lib/freeipa-data“ zu erstellen. Dieses wird als Datenverzeichnis für den FreeIPA-Server verwendet.

sudo mkdir -p /var/lib/freeipa-data

Führe nun den folgenden „docker run“-Befehl aus, um den FreeIPA-Server-Container zu erstellen und zu starten. In diesem Beispiel erstellst du einen neuen FreeIPA-Container namens„freeipa-server-almalinux9“ und speicherst die FreeIPA-Serverdaten auf dem Host-Rechner im Verzeichnis „/var/lib/freeipa-data„.

docker run --name freeipa-server-almalinux9 -ti \
    -h ipa.hwdomain.lan --read-only --sysctl net.ipv6.conf.all.disable_ipv6=0 \
    -v /sys/fs/cgroup:/sys/fs/cgroup:ro \
    -v /var/lib/freeipa-data:/data:Z freeipa-almalinux9

Während der Installation solltest du nach einigen Konfigurationen für den FreeIPA-Server gefragt werden.

Wenn du gefragt wirst, ob du den integrierten DNS über BIND einrichten willst, drücke ENTER oder gib no ein.

Gib nun den Hostnamen des Servers, den Domainnamen und den REALM für deinen FreeIPA-Server ein.

Gib nun ein neues Passwort ein und wiederhole dies für den Verzeichnismanager und den IPA-Admin-Benutzer.

Belasse den NetBIOS-Namen in der Standardeinstellung und drücke ENTER. Bei der NTP-Konfiguration gibst du no ein oder drückst einfach ENTER.

Überprüfe nun die Konfiguration deiner FreeIPA-Server-Installation. Wenn du fertig bist, gibst du„yes“ ein und drückst ENTER zur Bestätigung. Damit sollte die FreeIPA-Serverkonfiguration laufen und Zeit in Anspruch nehmen.

Wenn die FreeIPA Serverkonfiguration abgeschlossen ist, solltest du eine Ausgabe wie „Setup complete“ und die Anweisungen für die nächsten Schritte erhalten.

Öffne nun eine neue Terminalsitzung und verbinde dich mit deinem Debian-Server. Melde dich dann als Benutzer„bob“ an und gib den folgenden Docker-Befehl ein, um den laufenden Container auf deinem System zu überprüfen.

docker ps

Du solltest den Container namens„freeipa-server-almalinux9“ mit dem Status„Up“ sehen.

Jetzt läuft der FreeIPA-Server mit Daten, die im Verzeichnis„/var/lib/freeipa-data“ gespeichert sind. Im nächsten Schritt musst du die Portzuordnung für den FreeIPA-Server hinzufügen.

Gib folgenden Befehl ein, um den Container „freeipa-server-almalinux9“ zu stoppen und ihn zu entfernen. Dadurch wird zwar der Container entfernt, nicht aber das Datenverzeichnis „/var/lib/freeipa-data“.

docker stop freeipa-server-almalinux9
docker rm freeipa-server-almalinux9

Führe dann den folgenden Befehl aus, um einen neuen Container mit Port-Zuordnung für den FreeIPA-Server zu erstellen. Dadurch wird eine neue Version des Containers„freeipa-server-almalinux9“ mit spezifischen Ports erstellt, die dem Host-Rechner zugeordnet sind und die gleichen Daten wie der vorherige FreeIPA-Server verwenden.

docker run --name freeipa-server-almalinux9 -ti \
    -h ipa.hwdomain.lan -p 53:53/udp -p 53:53 -p 80:80 -p 443:443 -p 389:389 -p 636:636 -p 88:88 -p 464:464 -p 88:88/udp -p 464:464/udp -p 123:123/udp \
    --read-only --sysctl net.ipv6.conf.all.disable_ipv6=0 \
    -v /sys/fs/cgroup:/sys/fs/cgroup:ro \
    -v /var/lib/freeipa-data:/data:Z freeipa-almalinux9

Wechsle wieder in eine andere Terminalsitzung und führe den folgenden Befehl aus, um den Container „freeipa-server-almalinux9“ zu stoppen und erneut zu starten. Dadurch wird sichergestellt, dass der Container „freeipa-server-almalinux9“ im Hintergrund läuft.

docker stop freeipa-server-almalinux9
docker start freeipa-server-almalinux9

Wenn du die Liste der laufenden Container auf deinem System überprüfst, solltest du sehen, dass der Container „freeipa-server-almalinux9“ mit den neuen Ports, die dem Host-Rechner zugeordnet sind, läuft.

docker ps

Damit ist die Bereitstellung des FreeIPA-Servers über Docker abgeschlossen. Dein FreeIPA Server ist jetzt für Clients zugänglich und du hast das Administrator-Passwort für IPA admin und Directory Manager konfiguriert.

Authentifizierung gegenüber FreeIPA Server

Nachdem du den FreeIPA-Server über Docker installiert hast, überprüfst du die Installation, indem du dich gegenüber dem Kerberos FreeIPA-Server vom Docker-Host-Server aus authentifizierst. Dazu musst du sicherstellen, dass der Domänenname deines FreeIPA-Servers auf den richtigen Server zeigt und dass du die Kerberos-Client-Dienstprogramme installiert hast.

Bevor du beginnst, öffne die Datei„/etc/hosts“ auf deinem Debian-System mit dem folgenden Editor-Befehl nano.

sudo nano /etc/hosts

Füge die folgenden Zeilen in die Datei ein und achte darauf, dass du die IP-Adresse und den Domänennamen mit deinem FreeIPA Server-Host änderst.

192.168.5.10 ipa.hwdomain.lan

Speichere und schließe die Datei, wenn du fertig bist.

Als Nächstes installierst du das Paket„krb5-user“ mit dem unten stehenden apt-Befehl auf deinem System. Damit werden einige Kerberos-Dienstprogramme installiert, mit denen du dich mit deinem FreeIPA-Server verbinden kannst.

sudo apt install krb5-user

Gib y ein, wenn du dazu aufgefordert wirst, und drücke ENTER, um fortzufahren.

Wenn du nach der Standard-REALM-Konfiguration gefragt wirst, gib den REALM für deinen FreeIPA-Server ein – in diesem Beispiel ist der REALM„HWDOMAIN.LAN„.

Wie beim Kerberos-Server gibst du den Domänennamen deines FreeIPA-Servers ein, z. B. „ipa.hwdomain.lan“.

Verwende denselben Wert für den administrativen Server für den Kerberos-Realm –„ipa.hwdomain.lan„.

Jetzt sollte die Installation abgeschlossen sein und die neuen Einstellungen werden in der Datei„/etc/krb5.conf“ generiert.

Wenn die Kerberos-Dienstprogramme installiert sind, gibst du den folgenden Befehl ein, um die Authentifizierung am Kerberos-Server zu testen, der als Docker-Container läuft. Wenn du dazu aufgefordert wirst, gib das Admin-Passwort für deinen FreeIPA-Server ein.

kinit admin

Gib den folgenden Befehl ein, um die Authentifizierung am Kerberos-Server zu überprüfen. Wenn du erfolgreich bist, solltest du die Details zu den Tickets für deine Kerberos-Authentifizierung erhalten.

klist

Schließlich kannst du auch das Webadministrations-Dashboard deines FreeIPA-Servers besuchen. Vergewissere dich, dass der Domainname deines FreeIPA-Servers in der Datei „/etc/hosts“ auf deinem lokalen Rechner eingetragen ist.

Öffne deinen Webbrowser und rufe den Domänennamen des FreeIPA-Servers auf (z.B.: https://ipa.hwdomain.lan/). Wenn du erfolgreich warst, solltest du die Anmeldeseite des FreeIPA-Servers sehen.

Gib den Benutzer admin und dein Passwort ein und klicke dann auf Anmelden.

Wenn die Authentifizierung erfolgreich war, solltest du das Web-Administrations-Dashboard deines FreeIPA-Servers sehen.

Hinzufügen von FreeIPA-Benutzern und -Gruppen über den Befehl Linux

Es gibt verschiedene Methoden zur Verwaltung des FreeIPA-Servers, der als Docker-Container läuft. Du kannst ihn über das Web-Administrations-Dashboard verwalten oder das Verzeichnis vom FreeIPA-Server-Container aus verwalten. In diesem Abschnitt verwaltest du den FreeIPA-Benutzer und die FreeIPA-Gruppe über den Befehl „ipa“ im FreeIPA-Server-Container.

Gib zunächst den folgenden Befehl ein, um dich am Container„freeipa-server-almalinux9“ anzumelden.

docker exec -it freeipa-server-almalinux9 /bin/bash

Sobald du eingeloggt bist, authentifiziere dich mit dem Benutzer„admin“ gegenüber dem Kerberos-Server. Überprüfe dann die Details des Kerberos-Tickets. Wenn du nach dem Passwort gefragt wirst, gibst du das Passwort für deinen Directory Manager ein.

kinit admin
klist

Nachdem du dich am Kerberos-Server authentifiziert hast, kannst du nun mit der Konfiguration des FreeIPA-Servers beginnen.

Gib den folgenden„ipa config-mod„-Befehl ein, um die Standard-Shell für FreeIPA-Benutzer auf „/bin/bash“ einzustellen.

ipa config-mod --defaultshell=/bin/bash

Du solltest die Details der Benutzerkonfigurationen für den FreeIPA-Server sehen.

Als Nächstes gibst du den folgenden Befehl ein, um einen neuen FreeIPA-Benutzer namens„ubuntu“ anzulegen. Gib auch ein neues Passwort ein, wenn du dazu aufgefordert wirst, und wiederhole den Vorgang.

ipa user-add ubuntu --first=Ubuntu --last=Linux --password

Sobald du ihn hinzugefügt hast, solltest du eine Ausgabe wie„Benutzer „ubuntu“ hinzugefügt“ erhalten.

Gib nun den folgenden Befehl ein, um den Benutzer„ubuntu“ auf deinem FreeIPA-Server zu finden. Wenn der Benutzer verfügbar ist, solltest du eine Ausgabe wie„1 Benutzer gefunden“ erhalten. Außerdem kannst du die Details des Benutzers„ubuntu“ sehen.

ipa user-find ubuntu

Du kannst die Details der verfügbaren Benutzer auf FreIPA auch mit dem folgenden Befehl abrufen.

ipa user-show --raw ubuntu

Nachfolgend siehst du eine ähnliche Ausgabe, die du erhalten wirst.

Als Nächstes erstellst du eine neue Gruppe„development“ mit dem Befehl „ipa group-add“ und überprüfst die Gruppe, um sicherzustellen, dass sie hinzugefügt und verfügbar ist.

ipa group-add --desc='Development Team' development
ipa group-find development

Führe nun den folgenden Befehl „ipa group-add-member“ aus, um den FreeIPA-Benutzer„ubuntu“ zur Gruppe„development“ hinzuzufügen.

ipa group-add-member --user=ubuntu development

Überprüfe die Details der Gruppe„development“ mit folgendem Befehl. Du solltest sehen, dass der Benutzer„ubuntu“ der Gruppe„development“ hinzugefügt wurde.

ipa group-show development

Hinzufügen von Hosts zum FreeIPA Server

FreeIPA bietet die einfachste Möglichkeit, einen neuen Host zum FreeIPA-Server hinzuzufügen. Dies geschieht über das FreeIPA-Client-Paket, das das Dienstprogramm „ipa-client-install“ enthält. In diesem Abschnitt wirst du einen Ubuntu-Rechner zum FreeIPA-Server „ipa.hwdomain.lan“ hinzufügen, der als Container läuft.

Nachfolgend sind die Schritte aufgeführt, die du ausführen musst, um einen neuen Host zum FreeIPA-Server hinzuzufügen:

• FQDN und Zeitzone des Client-Rechners einrichten
• Installation der FreeIPA Client-Pakete
• Überprüfen des FreeIPA-Client-Rechners

Jetzt fügen wir den Ubuntu-Rechner zum FreeIPA Server Docker-Container hinzu.

FQDN und Zeitzone einrichten

Melde dich zunächst auf deinem Client-Rechner an und richte den FQDN mit dem folgenden Befehl ein.

sudo hostnamectl set-hostname client01.hwdomain.lan

Öffne nun die Konfigurationsdatei„/etc/hosts“ mit dem folgenden nano-Editor-Befehl.

sudo nano /etc/hosts

Füge die folgenden Zeilen in die Datei ein und achte darauf, dass du die Details der IP-Adresse, des fqdn und des Hostnamens änderst.

192.168.5.10    ipa.hwdomain.lan        ipa
192.168.5.121   client01.hwdomain.lan   client01

Speichere die Datei, wenn du fertig bist.

Gib nun den folgenden Befehl ein, um sicherzustellen, dass der fqdn des Client-Rechners auf die richtige IP-Adresse zeigt und dass der Domänenname des FreeIPA-Servers ebenfalls auf die korrekte und richtige IP-Adresse zeigt.

ping -c3 ipa.hwdomain.lan
ping -c3 client01.hwdomain.lan

Als Nächstes gibst du den folgenden Befehl ein, um die Zeitzone deines Client-Rechners einzustellen.

sudo timedatectl set-timezone Europe/Stockholm

Zum Schluss gibst du den folgenden Befehl ein, um die Datei„/etc/localtime“ auf die richtige Zeitzone einzustellen.

sudo unlink /etc/localtime
sudo ln -s /usr/share/timezone/Europe/Stockholm /etc/localtime

Installation von FreeIPA Client

Aktualisiere zunächst deinen Ubuntu-Paketindex mit dem unten stehenden apt-Befehl.

sudo apt update

Installiere nun das FreeIPA Client-Paket mit dem folgenden Befehl. Wenn du dazu aufgefordert wirst, gib zur Bestätigung y ein und drücke ENTER, um fortzufahren.

sudo apt install freeipa-client oddjob-mkhomedir

Wenn du nach dem Standard-REALM-Domainnamen gefragt wirst, gib deine Hauptdomain ein, z. B.„HWDOMAIN.LAN„.

Gib den Namen der Kerberos-Realm-Domäne mit der FreeIPA-Serverdomäne„ipa.hwdomain.lan“ ein.

Zuletzt gibst du wieder den Domänennamen des FreeIPA-Servers‚ipa.hwdomain.lan‚ als Verwaltungsserver für den Kerberos-Server ein.

Sobald das FreeIPA-Clientpaket installiert ist, führe den folgenden Befehl„ipa-client-install“ aus, um den Client-Rechner zum FreeIPA-Server hinzuzufügen. Achte darauf, dass du die Details des FreeIPA-Server-Domänennamens und des Realms änderst.

ipa-client-install --hostname=`hostname -f` \
--mkhomedir \
--server=ipa.hwdomain.lan \
--domain hwdomain.lan \
--realm HWDOMAIN.LAN

Wenn du gefragt wirst, ob du die festen Konfigurationen verwenden willst, bestätige mit Ja und drücke ENTER. Beim NTP-Server lässt du die Voreinstellung auf nein stehen. Zum Schluss bestätigst du die Installation mit Ja.

Unten siehst du die Ausgabe während der Installation und Konfiguration.

Sobald die Installation abgeschlossen ist, wird die Ausgabe„Der Befehl ipa-client-install war erfolgreich“ auf deinem Terminalbildschirm angezeigt.

FreeIPA-Client auf Hosts überprüfen

Gib auf dem FreeIPA-Server den folgenden Befehl ein, um dich mit dem FreeIPA-Benutzer „ubuntu“ mit dem Client-Rechner „192.168.5.121“ zu verbinden. Wenn du dazu aufgefordert wirst, bestätige mit „Ja“ und füge den SSH-Fingerabdruck des Client-Rechners hinzu und gib dann das Passwort für den FreeIPA-Benutzer „ubuntu“ ein.

ssh ubuntu@192.168.5.121

Sobald du eingeloggt bist, solltest du aufgefordert werden, das aktuelle Standardpasswort zu ändern. Gib also das aktuelle Passwort ein, gib das neue Passwort ein und wiederhole den Vorgang.

Zum Schluss gibst du den folgenden Befehl ein, um deinen aktuellen Benutzer zu identifizieren. Du solltest sehen, dass du dich mit dem Benutzer„ubuntu“ auf dem Client-Rechner angemeldet hast, der auch Teil der Gruppe„development“ ist.

id
whoami

Fazit

In diesem Lernprogramm hast du gelernt, wie du den FreeIPA-Server über Docker auf einem Debian 11-Server installierst und einsetzt. Außerdem hast du gelernt, wie du mit dem Befehl „ipa“ FreeIPA-Benutzer und -Gruppen anlegst und verwaltest. Außerdem hast du gelernt, wie du mit dem Befehl „kinit“ ein Kerberos-Ticket erhältst und dich mit dem Benutzer „admin“ und dem Passwort bei der FreeIPA-Webadministration anmeldest.

Schließlich hast du auch einen Ubuntu-Client-Rechner über das FreeIPA-Client-Paket zum FreeIPA-Server hinzugefügt. Du hast Schritt für Schritt gelernt, wie du das machst, und hast deine Einstellungen überprüft, indem du dich als FreeIPA-Benutzer auf dem Client-Rechner angemeldet hast.

Damit kannst du nun weitere Hosts, Benutzer und Gruppen zu deinem FreeIPA-Server hinzufügen. Du kannst FreeIPA auch in deine Produktion integrieren. Weitere Informationen findest du in der offiziellen Dokumentation von FreeIPA.