March 19, 2026

Kubernetes auf Ubuntu installieren und professionell verwalten

Kubernetes ist heute eine der wichtigsten Plattformen für den Betrieb von Containern in modernen Linux-Umgebungen. Wer Anwendungen nicht nur in einzelnen Containern starten, sondern sauber skalieren, überwachen und professionell verwalten möchte, kommt an Kubernetes kaum vorbei. Gerade unter Ubuntu ist Kubernetes sehr beliebt, weil Ubuntu auf Servern, in Laborumgebungen, in der Cloud und im Rechenzentrum häufig eingesetzt wird. Für Anfänger wirkt das Thema zuerst oft groß und technisch. Das ist verständlich, denn bei Kubernetes treffen viele Bausteine zusammen: Container Runtime, kubeadm, kubelet, kubectl, Pods, Cluster, Control Plane und Netzwerk-Plugin. In der Praxis lässt sich das aber gut Schritt für Schritt aufbauen, wenn die Grundidee klar erklärt wird. Die offizielle Kubernetes-Dokumentation beschreibt Kubernetes als Plattform zur Automatisierung von Deployment, Skalierung und Verwaltung containerisierter Anwendungen. Für Ubuntu gibt es zusätzlich offizielle Installations- und Dokumentationsseiten von Canonical. :contentReference[oaicite:0]{index=0}

In diesem Tutorial lernen Sie, wie Sie Kubernetes auf Ubuntu installieren und professionell verwalten. Dabei konzentriert sich die Anleitung auf eine saubere, anfängerfreundliche Einführung mit professionellem Blick auf Betrieb, Sicherheit und Wartung. Die Kubernetes-Dokumentation empfiehlt für klassische Linux-Installationen mit kubeadm eine klare Trennung zwischen Vorbereitung der Hosts, Installation der Pakete, Einrichtung einer Container Runtime und anschließender Cluster-Erstellung. Außerdem wird dort erklärt, dass die alten Paketquellen apt.kubernetes.io und yum.kubernetes.io seit dem 13. September 2023 veraltet und eingefroren sind und dass für neuere Versionen die Paketquellen unter pkgs.k8s.io verwendet werden sollen. Genau das ist für eine aktuelle Ubuntu-Installation besonders wichtig. :contentReference[oaicite:1]{index=1}

Table of Contents

Was ist Kubernetes unter Ubuntu?

Kubernetes ist eine Orchestrierungsplattform für Container. Das bedeutet: Kubernetes hilft dabei, Container nicht nur zu starten, sondern auch zu verteilen, zu überwachen, neu zu starten und bei Bedarf zu skalieren. Ein einzelner Container-Host reicht in vielen Testumgebungen aus. Sobald aber mehrere Anwendungen, Hochverfügbarkeit oder automatische Verwaltung wichtig werden, ist Kubernetes interessant. Die offizielle Kubernetes-Dokumentation beschreibt genau diesen Einsatzbereich: automatisierte Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen. :contentReference[oaicite:2]{index=2}

Unter Ubuntu kann Kubernetes auf verschiedene Arten eingesetzt werden. Es gibt einfache Entwicklungsumgebungen, vorkonfigurierte Snap-Lösungen von Canonical und klassische kubeadm-Installationen. Für Lernende ist kubeadm besonders interessant, weil man damit die Kernbestandteile von Kubernetes direkt kennenlernt. Genau deshalb orientiert sich dieses Tutorial an einem sauberen kubeadm-Ansatz auf Ubuntu. Die Kubernetes-Dokumentation stellt kubeadm ausdrücklich als Werkzeug zum Bootstrapping eines Clusters bereit. :contentReference[oaicite:3]{index=3}

Warum Ubuntu für Kubernetes oft eine gute Wahl ist

Ubuntu ist in der Container- und Cloud-Welt sehr weit verbreitet. Canonical stellt eigene Kubernetes-Dokumentation und Installationswege bereit, und Ubuntu wird in vielen Unternehmens- und Serverumgebungen als stabile Grundlage genutzt. Canonical beschreibt Kubernetes auf Ubuntu ausdrücklich als geeignete Plattform für Workstations, Clouds, Edge-Umgebungen und IoT-Szenarien. Gleichzeitig bietet die offizielle Canonical-Kubernetes-Dokumentation mehrere Installationswege an, darunter Snap-basierte Varianten. :contentReference[oaicite:4]{index=4}

Für Anfänger und IT-Studenten ist Ubuntu außerdem nützlich, weil viele Anleitungen, Werkzeuge und Community-Ressourcen verfügbar sind. Wer Kubernetes auf Ubuntu installiert, lernt gleichzeitig wichtige Linux-Grundlagen wie Paketverwaltung, Dienste, Netzwerke und Container-Laufzeiten kennen.

Wichtige Grundbegriffe vor der Installation

Bevor Sie Kubernetes auf Ubuntu installieren, sollten einige Grundbegriffe klar sein. Kubernetes besteht nicht aus nur einem einzigen Programm. Stattdessen arbeiten mehrere Komponenten zusammen.

Wichtige Kubernetes-Begriffe

Cluster: Die gesamte Kubernetes-Umgebung.
Node: Ein einzelner Server im Cluster.
Control Plane: Die Verwaltungsseite des Clusters.
Worker Node: Ein Node, auf dem Anwendungen laufen.
Pod: Die kleinste bereitstellbare Einheit in Kubernetes.
kubectl: Das wichtigste Kommandozeilen-Werkzeug für Verwaltung.
kubeadm: Werkzeug zum Einrichten eines Clusters.
kubelet: Agent, der auf jedem Node läuft.

Die offizielle Kubernetes-Dokumentation beschreibt kubectl als zentrales CLI-Werkzeug zur Verwaltung von Cluster-Ressourcen. Außerdem wird kubeadm als Werkzeug für das Aufsetzen eines Clusters dokumentiert. :contentReference[oaicite:5]{index=5}

Welche Installationswege gibt es?

Wer Kubernetes auf Ubuntu installieren möchte, hat mehrere Möglichkeiten. Für Lern- und Verwaltungszwecke sind vor allem zwei Ansätze interessant: eine klassische kubeadm-Installation und eine von Canonical bereitgestellte Ubuntu-nahe Lösung. Canonical weist in seiner aktuellen Dokumentation ausdrücklich darauf hin, dass es mehr als einen Installationsweg gibt. Gleichzeitig empfiehlt die allgemeine Kubernetes-Dokumentation, den Installationsweg passend zu Wartbarkeit, Sicherheit, Kontrolle und vorhandenem Wissen auszuwählen. :contentReference[oaicite:6]{index=6}

Für dieses Tutorial ist kubeadm besonders sinnvoll, weil Sie damit die Grundlagen professionell verstehen lernen. Sie sehen, welche Pakete installiert werden, welche Runtime nötig ist, wie der Control-Plane-Node initialisiert wird und wie Worker-Nodes später beitreten können.

Voraussetzungen für Kubernetes auf Ubuntu

Bevor Sie starten, sollten Ihre Ubuntu-Systeme einige Voraussetzungen erfüllen. Die aktuelle kubeadm-Dokumentation nennt als Voraussetzung einen kompatiblen Linux-Host und verlangt, dass Container Runtime und Kubernetes-Komponenten auf allen Hosts installiert werden. Kubernetes benötigt außerdem eine Container Runtime, weil Pods und Container sonst nicht ausgeführt werden können. Die offizielle Runtime-Dokumentation nennt containerd, CRI-O und andere CRI-kompatible Runtimes als unterstützte Optionen und weist darauf hin, dass Dockershim seit Kubernetes 1.24 entfernt wurde. Genau deshalb wird heute meist mit containerd gearbeitet. :contentReference[oaicite:7]{index=7}

Wichtige Voraussetzungen

Aktuelles Ubuntu-System
sudo-Rechte oder Root-Zugriff
Mindestens ein Host für die Control Plane
Bei Bedarf weitere Hosts für Worker-Nodes
Stabile Netzwerkkonfiguration
Container Runtime wie containerd

System vorbereiten und aktualisieren

Ein sauber vorbereiteter Host ist die Grundlage für einen stabilen Kubernetes-Betrieb. Vor jeder Installation sollten Paketlisten aktualisiert und bestehende Pakete auf den aktuellen Stand gebracht werden.

Paketlisten aktualisieren

sudo apt update

Pakete aktualisieren

sudo apt upgrade -y

Diese Schritte sind zwar einfach, aber im produktiven Betrieb wichtig. Gerade bei einem Cluster-Host sollten Sie mit einer sauberen, aktuellen Basis beginnen.

Container Runtime installieren: containerd

Kubernetes benötigt eine Container Runtime. Die offizielle Kubernetes-Dokumentation nennt containerd als eine der zentralen unterstützten Container Runtimes. Da Dockershim längst entfernt wurde, ist containerd heute für viele kubeadm-Installationen eine sehr sinnvolle Standardwahl. :contentReference[oaicite:8]{index=8}

containerd installieren

sudo apt install containerd -y

Konfigurationsverzeichnis sicherstellen

sudo mkdir -p /etc/containerd

Standardkonfiguration erzeugen

sudo containerd config default | sudo tee /etc/containerd/config.toml

In vielen Umgebungen wird danach die systemd-Cgroup-Nutzung passend gesetzt. Das ist in Kubernetes-Umgebungen ein häufiger und sinnvoller Schritt.

Datei bearbeiten

sudo nano /etc/containerd/config.toml

Suchen Sie die passende Stelle für SystemdCgroup und setzen Sie den Wert auf true.

Beispiel für die relevante Einstellung

SystemdCgroup = true

containerd neu starten

sudo systemctl restart containerd

Status prüfen

sudo systemctl status containerd

Swap deaktivieren

Für kubeadm-Installationen ist die Deaktivierung von Swap traditionell ein wichtiger Vorbereitungsschritt. In vielen Kubernetes-Anleitungen wird dieser Schritt weiterhin klar genannt, weil kubeadm und kubelet in Standardkonfigurationen damit sauberer arbeiten.

Swap temporär deaktivieren

sudo swapoff -a

Eintrag in /etc/fstab prüfen

sudo nano /etc/fstab

Dort sollten aktive Swap-Einträge auskommentiert werden, damit Swap nicht nach dem Neustart wieder automatisch aktiv wird.

Kubernetes-Pakete aus aktueller Quelle installieren

Die aktuelle Kubernetes-Dokumentation weist ausdrücklich darauf hin, dass die alten Paketquellen apt.kubernetes.io eingefroren und veraltet sind und dass für neuere Versionen die Paketquellen unter pkgs.k8s.io genutzt werden sollen. Das ist heute einer der wichtigsten Punkte für eine saubere Ubuntu-Installation. :contentReference[oaicite:9]{index=9}

Benötigte Werkzeuge installieren

sudo apt install -y apt-transport-https ca-certificates curl gpg

Schlüsselverzeichnis vorbereiten

sudo mkdir -p -m 755 /etc/apt/keyrings

Kubernetes-Repository-Schlüssel laden

curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.33/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

Repository eintragen

echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.33/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

Paketlisten aktualisieren

sudo apt update

kubelet, kubeadm und kubectl installieren

sudo apt install -y kubelet kubeadm kubectl

Pakete auf Hold setzen

sudo apt-mark hold kubelet kubeadm kubectl

Die konkrete Repository-Version kann sich mit der Zeit ändern. Das gezeigte Beispiel orientiert sich an der aktuellen Struktur der offiziellen Paketquellen. Kubernetes dokumentiert außerdem versionsspezifische Installationsseiten, etwa für v1.33 oder neuere Varianten. :contentReference[oaicite:10]{index=10}

Die wichtigsten Werkzeuge prüfen

Nach der Installation sollten Sie kontrollieren, ob die zentralen Kubernetes-Komponenten verfügbar sind.

kubectl-Version prüfen

kubectl version --client

kubeadm-Version prüfen

kubeadm version

kubelet-Status prüfen

sudo systemctl status kubelet

Es ist normal, dass kubelet vor der eigentlichen Cluster-Initialisierung noch nicht vollständig „fertig“ wirkt. Der Dienst wird erst im Zusammenhang mit einem eingerichteten Cluster vollständig sinnvoll aktiv.

Den ersten Kubernetes-Cluster mit kubeadm initialisieren

Jetzt folgt der zentrale Schritt: die Initialisierung des Control-Plane-Nodes. Die offizielle kubeadm-Dokumentation beschreibt kubeadm init als Standardweg für die Einrichtung eines neuen Control-Plane-Knotens. Sie dokumentiert außerdem, dass standardmäßig Images aus registry.k8s.io verwendet werden. :contentReference[oaicite:11]{index=11}

Cluster initialisieren

sudo kubeadm init --pod-network-cidr=192.168.0.0/16

Die Angabe für –pod-network-cidr hängt vom später verwendeten CNI-Netzwerk-Plugin ab. Ein Wert wie 192.168.0.0/16 wird häufig bei Calico verwendet. Wichtig ist, dass die Wahl zum späteren Netzwerk-Plugin passt.

Nach erfolgreicher Initialisierung zeigt kubeadm mehrere wichtige Informationen an, darunter auch den kubeadm join-Befehl für spätere Worker-Nodes.

kubectl für den aktuellen Benutzer einrichten

Nach kubeadm init muss kubectl für den gewünschten Benutzer eingerichtet werden. Ohne diese Schritte kann kubectl den Cluster oft nicht verwalten.

Kube-Konfiguration vorbereiten

mkdir -p $HOME/.kube

Admin-Konfiguration kopieren

sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

Besitzerrechte anpassen

sudo chown $(id -u):$(id -g) $HOME/.kube/config

Cluster-Status prüfen

kubectl get nodes

Der Node kann zu diesem Zeitpunkt oft noch nicht vollständig Ready sein, weil das Pod-Netzwerk noch fehlt. Genau das ist der nächste wichtige Schritt.

Ein CNI-Netzwerk-Plugin installieren

Ein Kubernetes-Cluster braucht ein Pod-Netzwerk, damit Pods miteinander kommunizieren können. Die offizielle kubeadm-Dokumentation beschreibt ausdrücklich, dass nach der Control-Plane-Initialisierung ein Pod-Netzwerk installiert werden muss, damit Pods miteinander sprechen können. :contentReference[oaicite:12]{index=12}

In der Praxis werden häufig Plugins wie Calico oder Flannel genutzt. Für viele Lern- und Laborszenarien ist Calico eine verbreitete Wahl.

Beispiel mit Calico

kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/master/manifests/calico.yaml

Danach dauert es meist einen Moment, bis die Netzwerk-Pods laufen und der Node den Status Ready erreicht.

Nodes erneut prüfen

kubectl get nodes

Pods im System-Namespace prüfen

kubectl get pods -n kube-system

Worker-Nodes dem Cluster hinzufügen

Wenn Sie nicht nur einen einzelnen Node verwenden möchten, können weitere Nodes dem Cluster beitreten. kubeadm zeigt nach der Initialisierung einen passenden Join-Befehl an. Dieser Join-Befehl wird auf dem Worker-Node ausgeführt.

Beispiel für einen Join-Befehl

sudo kubeadm join 192.168.1.100:6443 --token TOKEN_WERT --discovery-token-ca-cert-hash sha256:HASH_WERT

Der genaue Befehl ist clusterspezifisch. Er wird von kubeadm ausgegeben und kann bei Bedarf neu erzeugt werden.

Neuen Token erzeugen

kubeadm token create --print-join-command

So können Sie weitere Worker-Nodes später sauber in den Cluster integrieren.

Kubernetes professionell verwalten: die wichtigsten kubectl-Befehle

Wer Kubernetes auf Ubuntu professionell verwalten möchte, muss mit kubectl sicher umgehen können. kubectl ist das wichtigste Verwaltungswerkzeug. Die offizielle Kubernetes-Dokumentation beschreibt kubectl als das Kommandozeilenwerkzeug zur Verwaltung von Anwendungen und Ressourcen im Cluster. :contentReference[oaicite:13]{index=13}

Nodes anzeigen

kubectl get nodes

Pods anzeigen

kubectl get pods -A

Namespaces anzeigen

kubectl get namespaces

Dienstinformationen anzeigen

kubectl get svc -A

Ressourcen beschreiben

kubectl describe node NODE_NAME

Logs eines Pods anzeigen

kubectl logs POD_NAME -n NAMESPACE

Diese Befehle sind im Alltag extrem wichtig, weil sie Überblick und Fehleranalyse ermöglichen.

Eine erste Testanwendung bereitstellen

Nach der Cluster-Einrichtung sollten Sie eine einfache Anwendung deployen. So sehen Sie, ob Pods korrekt starten und das Netzwerk funktioniert.

Test-Deployment erstellen

kubectl create deployment nginx --image=nginx

Deployments prüfen

kubectl get deployments

Pods prüfen

kubectl get pods

Wenn der Pod sauber startet, ist das ein gutes Zeichen dafür, dass Control Plane, kubelet, Runtime und Netzwerk zusammenarbeiten.

Kubernetes-Ressourcen sauber mit YAML verwalten

Für professionelle Verwaltung sollten Sie nicht nur mit spontanen CLI-Befehlen arbeiten. Kubernetes ist besonders stark, wenn Ressourcen deklarativ mit YAML-Dateien verwaltet werden. So bleiben Deployments wiederholbar, dokumentiert und versionierbar.

Beispiel für eine einfache Deployment-Datei

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
      - name: webapp
        image: nginx
        ports:
        - containerPort: 80

Datei anwenden

kubectl apply -f deployment.yaml

So lernen Sie gleichzeitig die Arbeitsweise, die auch in produktiven Umgebungen üblich ist.

Sicherheit und Best Practices für den produktiven Betrieb

Ein Kubernetes-Cluster sollte nicht nur laufen, sondern auch sauber abgesichert werden. Dazu gehören aktuelle Paketstände, kontrollierte Benutzerzugriffe, sichere Netzwerke und eine klare Trennung von Test und Produktion. Die allgemeine Kubernetes-Dokumentation empfiehlt ausdrücklich, den Installationsweg auch nach Sicherheit, Wartbarkeit und Kontrolle auszuwählen. Genau das gilt später auch für den laufenden Betrieb. :contentReference[oaicite:14]{index=14}

Wichtige Best Practices

Nur notwendige Ports auf den Hosts freigeben
Ubuntu und Kubernetes-Komponenten aktuell halten
YAML-Dateien versionieren und dokumentieren
Zugriffe mit Rollen und Accounts bewusst steuern
Logs und Clusterzustand regelmäßig prüfen

Kubernetes unter Ubuntu aktualisieren und pflegen

Ein professionell verwalteter Cluster braucht Wartung. Dazu gehören Updates von kubeadm, kubelet und kubectl sowie ein sauber geplanter Upgrade-Prozess. Die offizielle Kubernetes-Dokumentation weist außerdem auf Versions- und Version-Skew-Regeln hin. Das ist wichtig, weil nicht beliebige Versionsmischungen zwischen Komponenten sinnvoll sind. :contentReference[oaicite:15]{index=15}

Wichtige Wartungsschritte

Versionen regelmäßig prüfen
Upgrade-Pfade planen
Vor Änderungen Status und Ressourcen sichern
Clusterzustand vor und nach Updates kontrollieren

Versionen prüfen

kubectl version --client
kubeadm version
kubelet --version

Typische Fehler bei Kubernetes auf Ubuntu

Viele Probleme entstehen nicht durch Kubernetes selbst, sondern durch kleine Vorbereitungsfehler. Gerade Anfänger profitieren davon, typische Stolperfallen zu kennen.

Häufige Fehler

Die veralteten alten Paketquellen werden verwendet
Swap wurde nicht deaktiviert
containerd ist nicht korrekt eingerichtet
Das CNI-Netzwerk-Plugin fehlt
kubectl wurde für den Benutzer nicht korrekt eingerichtet
Ports oder Firewall blockieren Cluster-Kommunikation

Die offiziellen Kubernetes-Dokumente nennen die neuen Paketquellen unter pkgs.k8s.io ausdrücklich als Standard für aktuelle Versionen. Genau dieser Punkt ist heute besonders wichtig. :contentReference[oaicite:16]{index=16}

Eine sinnvolle Lernstrategie für Anfänger und Fortgeschrittene

Kubernetes ist groß, aber es muss nicht chaotisch gelernt werden. Der beste Weg ist, zuerst einen einfachen Single-Control-Plane-Cluster mit kubeadm unter Ubuntu aufzubauen. Danach sollten Sie verstehen, wie containerd, kubeadm, kubelet, kubectl und das CNI-Plugin zusammenspielen. Erst dann lohnt sich der nächste Schritt mit mehreren Nodes, komplexeren Deployments oder produktiveren Themen wie Ingress, Storage und Monitoring.

Empfohlene Reihenfolge

Ubuntu vorbereiten und aktualisieren
containerd installieren und konfigurieren
Kubernetes-Pakete aus aktueller Quelle installieren
kubeadm init ausführen
kubectl für den Benutzer einrichten
CNI-Netzwerk-Plugin installieren
Ersten Test-Pod deployen
Danach Worker-Nodes und YAML-Verwaltung ergänzen

Diese Methode ist deutlich besser als sofort mit zu vielen Add-ons oder komplexen Produktivmustern zu starten.

Wichtige Befehle im Überblick

Wenn Sie Kubernetes auf Ubuntu installieren und professionell verwalten möchten, sollten Sie diese Befehle sicher kennen.

System aktualisieren

sudo apt update
sudo apt upgrade -y

containerd installieren

sudo apt install containerd -y

containerd-Konfiguration erzeugen

sudo containerd config default | sudo tee /etc/containerd/config.toml

Swap deaktivieren

sudo swapoff -a

Kubernetes-Pakete installieren

sudo apt install -y kubelet kubeadm kubectl

Pakete auf Hold setzen

sudo apt-mark hold kubelet kubeadm kubectl

Cluster initialisieren

sudo kubeadm init --pod-network-cidr=192.168.0.0/16

kubectl einrichten

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

Nodes prüfen

kubectl get nodes

System-Pods prüfen

kubectl get pods -n kube-system

Join-Befehl erzeugen

kubeadm token create --print-join-command

Test-Deployment erstellen

kubectl create deployment nginx --image=nginx

Wer diese Grundlagen sauber versteht und konsequent übt, baut auf Ubuntu nicht nur einen funktionierenden Kubernetes-Cluster auf, sondern schafft auch eine professionelle Grundlage für den späteren Betrieb. Genau das ist am Anfang entscheidend: erst die Architektur sauber verstehen, dann Installation und Verwaltung sicher beherrschen und erst danach komplexere produktive Themen wie Hochverfügbarkeit, Ingress, Storage-Klassen oder Cluster-Updates weiter vertiefen. :contentReference[oaicite:17]{index=17}

::contentReference[oaicite:18]{index=18}

Konfiguriere Cisco Router & Switches und liefere ein Packet-Tracer-Lab/GNS3

Ich biete professionelle Unterstützung im Bereich Netzwerkkonfiguration und Network Automation für private Anforderungen, Studienprojekte, Lernlabore, kleine Unternehmen sowie technische Projekte. Ich unterstütze Sie bei der Konfiguration von Routern und Switches, der Erstellung praxisnaher Topologien in Cisco Packet Tracer, dem Aufbau und Troubleshooting von GNS3- und EVE-NG-Labs sowie bei der Automatisierung von Netzwerkaufgaben mit Netmiko, Paramiko, NAPALM und Ansible. Kontaktieren Sie mich jetzt – klicken Sie hier.

Meine Leistungen umfassen:

Professionelle Konfiguration von Routern und Switches
Einrichtung von VLANs, Trunks, Routing, DHCP, NAT, ACLs und weiteren Netzwerkfunktionen
Erstellung von Topologien und Simulationen in Cisco Packet Tracer
Aufbau, Analyse und Fehlerbehebung von Netzwerk-Labs in GNS3 und EVE-NG
Automatisierung von Netzwerkkonfigurationen mit Python, Netmiko, Paramiko, NAPALM und Ansible
Erstellung von Skripten für wiederkehrende Netzwerkaufgaben
Dokumentation der Konfigurationen und Bereitstellung nachvollziehbarer Lösungswege
Konfigurations-Backups, Optimierung bestehender Setups und technisches Troubleshooting

Benötigen Sie Unterstützung bei Ihrem Netzwerkprojekt, Ihrer Simulation oder Ihrer Network-Automation-Lösung? Kontaktieren Sie mich jetzt – klicken Sie hier.