Help us improve your experience.

Let us know what you think.

Do you have time for a two-minute survey?

 
AUF DIESER SEITE
 

Installieren von cRPD auf Kubernetes

Kubernetes ist eine Open-Source-Plattform für die Verwaltung containerisierter Workloads und Services. Container sind eine gute Möglichkeit, die Anwendungen zu bündeln und auszuführen.

Verwalten Sie Container, auf denen Anwendungen in Produktionsumgebungen ausgeführt werden. Stellen Sie sicher, dass es keine Ausfallzeiten gibt. Wenn beispielsweise ein Container ausfällt, muss ein anderer Container gestartet werden. Kubernetes bietet Ihnen ein Framework, um verteilte Systeme ausfallsicher zu betreiben. Kubernetes bietet eine Plattform für die Bereitstellung, Automatisierung, Skalierung und den Betrieb von Anwendungscontainern über Cluster von Host-Containern hinweg.

Voraussetzung

Installieren von Kubernetes auf einem Linux-System und Bereitstellen von Kubernetes auf einem Linux-Cluster mit zwei Knoten finden Sie unter Kubernetes-Installation.

Wenn Sie Kubernetes bereitstellen, erhalten Sie einen Cluster. Ein Kubernetes-Cluster besteht aus einer Reihe von Arbeitscomputern, sogenannten Knoten, auf denen containerisierte Anwendungen ausgeführt werden. Jeder Cluster verfügt über mindestens einen Workerknoten. Die Workerknoten hosten die Pods, die die Komponenten der Anwendung sind.

In diesem Abschnitt werden die Schritte zum Erstellen des cRPD-Docker-Images in Kubernetes beschrieben.

Installieren von Kubernetes

So installieren Sie Kubernetes:

  1. Melden Sie sich als Root-Benutzer an.
  2. Laden Sie die Software herunter und installieren Sie sie.
  3. Starten Sie Kubernetes.

Kubernetes-Cluster

Kubernetes koordiniert einen Cluster von Computern, die miteinander verbunden sind, um als eine Einheit zu arbeiten. Kubernetes automatisiert die Bereitstellung und Planung von cRPD in einem Cluster auf effiziente Weise.

Ein Kubernetes-Cluster besteht aus zwei Arten von Ressourcen:

  • Der primäre Server koordiniert den Cluster

  • Nodes sind die Worker, die Anwendungen ausführen

Der primäre Server ist für die Verwaltung des Clusters verantwortlich. Der primäre Server koordiniert alle Aktivitäten in Ihrem Cluster, z. B. das Planen von Anwendungen, das Beibehalten des gewünschten Zustands von Anwendungen, das Skalieren von Anwendungen und das Bereitstellen neuer Updates.

Ein Knoten ist eine VM oder ein physischer Computer, der als Arbeitscomputer in einem Kubernetes-Cluster dient. Jeder Knoten verfügt über ein Kubelet, einen Agenten für die Verwaltung des Knotens und die Kommunikation mit dem Kubernetes-Master. Der Knoten sollte auch über Tools zum Verarbeiten von Containervorgängen verfügen, z. B. Docker oder rkt. Ein Kubernetes-Cluster, der den Produktionsdatenverkehr verarbeitet, sollte über mindestens drei Knoten verfügen.

Wenn Sie cRPD auf Kubernetes bereitstellen, startet der primäre Server die Anwendungscontainer. Der primäre Server plant die Ausführung der Container auf den Knoten des Clusters. Die Knoten kommunizieren mit dem primären Knoten über die Kubernetes-API, die der primäre Knoten verfügbar macht. Endbenutzer können die Kubernetes-API auch direkt für die Interaktion mit dem Cluster verwenden.

Ein Pod läuft immer auf einem Node. Ein Node ist ein Workercomputer in Kubernetes und kann je nach Cluster entweder ein virtueller oder ein physischer Computer sein. Jeder Knoten wird vom primären Knoten verwaltet. Ein Knoten kann mehrere Pods haben, und der primäre Kubernetes-Knoten übernimmt automatisch die Planung der Pods für die Knoten im Cluster.

Auf jedem Kubernetes-Knoten wird mindestens Folgendes ausgeführt:

  • Kubelet, ein Prozess, der für die Kommunikation zwischen dem primären Kubernetes-Server und dem Node verantwortlich ist; Es verwaltet die Pods und Container, die auf einem Computer ausgeführt werden.

  • Eine Containerlaufzeit (wie Docker, rkt), die für das Abrufen des Containerimages aus einer Registrierung, das Entpacken des Containers und das Ausführen der Anwendung verantwortlich ist.

So erstellen Sie einen minikube-Cluster:

  1. Führen Sie den folgenden Befehl aus, um die minikube-Version zu überprüfen:
  2. Führen Sie den folgenden Befehl aus, um den Cluster zu starten:
  3. Führen Sie den folgenden Befehl aus, um zu überprüfen, ob kubectl installiert ist:
  4. Führen Sie den folgenden Befehl aus, um die Clusterdetails anzuzeigen:
  5. Führen Sie den folgenden Befehl aus, um die Knoten im Cluster anzuzeigen:

cRPD Docker-Image herunterladen

Voraussetzungen

  • Stellen Sie vor dem Importieren der cRPD-Software sicher, dass Docker auf dem Linux-Host installiert ist und dass die Docker-Engine ausgeführt wird.

  • Stellen Sie sicher, dass Sie sich beim Juniper Support registrieren, bevor Sie die cRPD-Software herunterladen.

So laden Sie das Docker-Image herunter:

  1. Melden Sie sich bei der Juniper Docker-Registrierung mit den Anmeldeinformationen an, die Sie während des Verkaufsabwicklungsprozesses für cRPD angegeben haben.
    1. Erstellen Sie die Datei -passwd.txt und kopieren Sie das Zugriffstoken mit Ausnahme der Angebote des Kundendienstteams von Juniper.
    2. Melden Sie sich mit dem folgenden Befehl beim Enterprise Hub an:
      root@ubuntu-vm18$ cat passwd.txt | docker login -u"<registered-email-id>" --password-stdin enterprise-hub.juniper.net:443

      Zum Beispiel root@ubuntu-vm18$ cat passwd.txt | docker login -u user@domain.com --password-stdin enterprise-hub.juniper.net:443

  2. Rufen Sie das Docker-Image mit dem folgenden Befehl von der Download-Site ab:

    root@dc-rpd-01# docker pull enterprise-hub.juniper.net:443/crpd-docker-prod/crpd:<release tag>

    Zum Beispiel

    root@ubuntu-vm18:~# docker pull enterprise-hub.juniper.net:443/crpd-docker-prod/crpd:22.3R1

  3. Überprüfen Sie Images im Docker-Image-Repository.

    root@dc-rpd-01# docker images

Erstellen eines cRPD-Pods mithilfe der Bereitstellung

Ein Kubernetes-Pod ist eine Gruppe aus einem oder mehreren Containern, die zu Verwaltungs- und Netzwerkzwecken miteinander verbunden sind. Ein Kubernetes-Deployment überprüft den Zustand Ihres Pods und startet den Container des Pods neu, wenn er beendet wird. Bereitstellungen sind die empfohlene Methode, um die Erstellung und Skalierung von Pods zu verwalten.

Wenn Sie einen gewünschten Zustand in einer Bereitstellung beschreiben und der Bereitstellungscontroller den tatsächlichen Zustand in den gewünschten Zustand ändert. Sie können Bereitstellungen verwenden, um neue ReplicaSets zu erstellen. Alternativ können Sie vorhandene Bereitstellungen entfernen und ihre Ressourcen mit neuen Bereitstellungen übernehmen.

  1. Erstellen Sie die Datei crpd.yaml auf Kubernetes-primary und fügen Sie den folgenden Textinhalt hinzu:
  2. Speichern Sie die Datei crpd.yaml, um den cRPD-Pod zu erstellen.

    root@kubernetes-master:~# kubectl create -f crpd.yaml

  3. Führen Sie den folgenden Befehl aus, um die Liste der vorhandenen Pods anzuzeigen:

    root@kubernetes-master:~# kubectl get pods

  4. Führen Sie den folgenden Befehl aus, um die Container im Pod und die Images anzuzeigen, die zum Erstellen verwendet wurden:

    root@kubernetes-master:~# kubectl describe pod crpd

Erstellen eines cRPD-Pods mit YAML

Ein Pod ist die grundlegende Ausführungseinheit einer Kubernetes-Anwendung – die kleinste und einfachste Einheit im Kubernetes-Objektmodell, die Sie erstellen oder bereitstellen. Ein Pod stellt eine Bereitstellungseinheit dar: eine einzelne Instanz einer Anwendung in Kubernetes, die entweder aus einem einzelnen Container oder einer kleinen Anzahl von Containern bestehen kann, die eng gekoppelt sind und sich Ressourcen teilen. Docker ist die gebräuchlichste Container-Runtime, die in einem Kubernetes-Pod verwendet wird.

Sie können direkt einen Pod erstellen oder indirekt einen Controller in Kubernetes verwenden. Ein Controller kann mehrere Pods erstellen und verwalten. Controller verwenden eine Pod-Vorlage, die Sie zum Erstellen der Pods bereitstellen. Pod-Vorlagen sind Pod-Spezifikationen, die in anderen Objekten enthalten sind, z. B. Replikationscontrollern, Aufträgen und DaemonSets.

So erstellen Sie den cRPD-Pod mithilfe der YAML-Datei

  1. Erstellen Sie die Datei crpd.yaml unter Kubernetes-primary und fügen Sie den folgenden Textinhalt hinzu:
  2. Speichern Sie die Datei crpd.yaml, um den crpd-Pod zu erstellen.

    root@kubernetes-master:~# kubectl create -f crpd.yaml

  3. Führen Sie den folgenden Befehl aus, um die Liste der vorhandenen Pods anzuzeigen:

    root@kubernetes-master:~# kubectl get pods

  4. Führen Sie den folgenden Befehl aus, um die Container im Pod und die Images anzuzeigen, die zum Erstellen verwendet wurden:

    root@kubernetes-master:~# kubectl describe pod crpd

  5. Führen Sie den folgenden Befehl aus, um eine interaktive CLI innerhalb des ausgeführten Containers bereitzustellen:

    root@kubernetes-master:~# kubectl exec -it crpd cli

    Hier führst du einen Pod mit dem Namen crpd aus und verbindest dich mit dem Kommandozeilenmodus.

  6. Führen Sie den folgenden Befehl aus, um die Routen anzuzeigen:

    root@crpd:/> show route

Jeder Pod ist für die Ausführung einer einzelnen Instanz einer bestimmten Anwendung vorgesehen. Wenn Sie Ihre Anwendung horizontal skalieren möchten (z. B. mehrere Instanzen ausführen), sollten Sie mehrere Pods verwenden, einen für jede Instanz. In Kubernetes wird dies allgemein als Replikation bezeichnet.

Siehe auch

Erstellen eines cRPD-Pods mithilfe einer Auftragsressource

Ein Auftrag erstellt einen oder mehrere Pods und wiederholt die Ausführung der Pods, bis eine bestimmte Anzahl von Pods erfolgreich beendet wurde. Wenn eine bestimmte Anzahl erfolgreicher Abschlüsse erreicht ist, ist die Aufgabe abgeschlossen. Sie können einen Auftrag auch verwenden, um mehrere Pods parallel auszuführen. Durch das Löschen eines Auftrags werden die von ihm erstellten Pods bereinigt. Durch das Anhalten eines Auftrags werden die aktiven Pods gelöscht, bis der Auftrag fortgesetzt wird. So erstellen Sie den cRPD-Pod mit der Datei crpd_job.yaml:

  1. Erstellen Sie die Datei crpd_job.yaml auf Arbeitsknoten, und fügen Sie den folgenden Textinhalt hinzu:
  2. Speichern Sie die Datei crpd_job.yaml, um den crpd-Pod zu erstellen.

    root@kubernetes-master:~# kubectl create -f crpd_job.yaml

  3. Führen Sie den folgenden Befehl aus, um die Liste der vorhandenen Pods anzuzeigen:

    root@kubernetes-master:~# kubectl get pods

  4. Führen Sie den folgenden Befehl aus, um die Container im Pod und die Images anzuzeigen, die zum Erstellen verwendet wurden:

    root@kubernetes-master:~# kubectl describe job/crpdjob

Erstellen eines cRPD-Pods mit DaemonSet

DaemonSet stellt sicher, dass alle (oder einige) Knoten eine Kopie eines Pods ausführen. Wenn Knoten zum Cluster hinzugefügt werden, werden ihnen Pods hinzugefügt. Wenn Knoten aus dem Cluster entfernt werden, werden diese Pods einer Garbage Collection unterzogen. Wenn das DaemonSet gelöscht wird, werden die erstellten Pods gelöscht.

Erstellen des cRPD-Pods mithilfe der Datei crpd_daemonset.yaml

  1. Erstellen Sie die Datei crpd_daemonset.yaml auf Arbeitsknoten, und fügen Sie den folgenden Textinhalt hinzu:
  2. Speichern Sie die Datei da1.yaml, um den crpd-Pod zu erstellen.

    root@kubernetes-master:~# kubectl create -f crpd_daemonset.yaml

  3. Führen Sie den folgenden Befehl aus, um die Liste der vorhandenen Pods anzuzeigen:

    root@kubernetes-master:~# kubectl get pods

  4. Führen Sie den folgenden Befehl aus, um Container im Pod und die Images anzuzeigen, die zum Erstellen verwendet wurden:

    root@kubernetes-master:~# kubectl describe pod crpd

    root@kubernetes-master:~# kubectl describe pod crpd-5fc4fd79df-xr8f5

Jeder Pod ist für die Ausführung einer einzelnen Instanz einer bestimmten Anwendung vorgesehen. Wenn Sie Ihre Anwendung horizontal skalieren möchten (z. B. mehrere Instanzen ausführen), sollten Sie mehrere Pods verwenden, einen für jede Instanz. In Kubernetes wird dies allgemein als Replikation bezeichnet.

Siehe auch

cRPD skalieren

Sie können mehrere Instanzen von cRPD basierend auf dem Bedarf erstellen, indem Sie den –replicas Parameter für den kubectl run Befehl verwenden. Deployment ist ein Objekt, das seine ReplicaSets besitzen und verwalten kann.

Wir sollten vor der Skalierung einen Pod haben.

So skalieren Sie auf:

  1. Erstellen Sie den Pod.

    root@kubernetes-master:~# kubectl create -f crpd_replicatset.yaml

  2. Erstellen Sie die crpd_replicaSet.yaml-Datei auf Kubernetes-primary und fügen Sie den folgenden Textinhalt hinzu:
  3. Führen Sie den folgenden Befehl aus, um die Pods anzuzeigen:

    root@kubernetes-master:~# kubectl get pods

  4. Führen Sie den folgenden Befehl aus, um die Bereitstellung auf vier Replikate zu skalieren:

    root@kubernetes-master:~# kubectl scale deployments crpdref --replicas=4

  5. Führen Sie den folgenden Befehl aus, um die Bereitstellungen aufzulisten:

    root@kubernetes-master:~# kubectl get deployments

  6. Führen Sie den folgenden Befehl aus, um die Anzahl der geänderten Pods zu überprüfen:

    root@kubernetes-master:~# kubectl get pods -o wide

  7. Führen Sie den folgenden Befehl aus, um die Details der Pods zu überprüfen:

    root@kubernetes-master:~# kubectl describe pods

So verringern Sie die Skalierung:

  1. Führen Sie den folgenden Befehl aus, um den Dienst auf zwei Replikate herunterzuskalieren:

    root@kubernetes-master:~# kubectl scale deployments crpdref --replicas=2

  2. Führen Sie den folgenden Befehl aus, um die Bereitstellungen aufzulisten:

    root@kubernetes-master:~# kubectl get deployments

  3. Führen Sie den folgenden Befehl aus, um die Anzahl der Pods aufzulisten. Sie können sehen, dass die beiden Pods beendet wurden:

    root@kubernetes-master:~# kubectl get pods -o wide

Rollenaktualisierung der cRPD-Bereitstellung

Sie können Pod-Instanzen mit neuen Versionen aktualisieren. Fortlaufende Updates ermöglichen die Aktualisierung von Bereitstellungen ohne Ausfallzeiten, indem Pods-Instanzen inkrementell mit neuen aktualisiert werden. Die neuen Pods werden auf Knoten mit verfügbaren Ressourcen geplant. Rollback-Updates fördern eine Anwendung von einer Umgebung in eine andere mit kontinuierlicher Integration und kontinuierlicher Bereitstellung von Anwendungen ohne Ausfallzeiten. In Kubernetes werden Updates versioniert, und jedes Deployment-Update kann auf eine vorherige stabile Version zurückgesetzt werden.

So aktualisieren Sie die cRPD-Bereitstellung mit einem neuen Image und behalten die Konfiguration nach dem Update bei:

  1. Erstellen Sie den cRPD-Pod.

    root@crpd-01:~# kubectl kubectl create -f crpd_deploy.yaml

  2. Erstellen Sie die crpd_deploy.yaml-Datei auf Kubernetes-primary und fügen Sie den folgenden Textinhalt hinzu:
  3. Führen Sie den folgenden Befehl aus, um die Bereitstellungen aufzulisten:

    root@kubernetes-master:~# kubectl get deployments

  4. Führen Sie den folgenden Befehl aus, um die ausgeführten Pods aufzulisten:

    root@kubernetes-master:~# kubectl get pods

    root@kubernetes-master:~# kubectl get pods -o wide

  5. Führen Sie den folgenden Befehl aus, um die aktuelle Imageversion des cRPD anzuzeigen:

    root@kubernetes-master:~# kubectl exec -it crpd-deploy4-674b4fcfb5-8xc5d -- cli

  6. Führen Sie den folgenden Befehl aus, um die aktuelle Imageversion anzuzeigen:

    root@crpd-deploy4-674b4fcfb5-8xc5d> show version

  7. Führen Sie den folgenden Befehl aus, um das Image der Anwendung auf die neue Version zu aktualisieren:

    root@crpd-deploy4-674b4fcfb5-8xc5d:~$ sudo kubectl edit deployment/crpd-deploy4

  8. Führen Sie den folgenden Befehl aus, um zu überprüfen, ob das Image aktualisiert wurde:

    root@crpd-deploy4-674b4fcfb5-8xc5d:~$ sudo kubectl rollout status deployment/crpd-deploy4

  9. Führen Sie den folgenden Befehl aus, um die Pods anzuzeigen:

    root@crpd-deploy4-674b4fcfb5-8xc5d> kubectl get pods

  10. Führen Sie den folgenden Befehl aus, um die Imageversion des cRPD anzuzeigen:

    root@kubernetes-master:~$ sudo kubectl exec -it crpd-deploy4-6ff476994d-8z2kr -- bash

  11. Führen Sie den folgenden Befehl aus, um die aktuelle Imageversion anzuzeigen:

    root@crpd-deploy4-6ff476994d-8z2kr> show version

cRPD-Pod-Bereitstellung mit zugewiesenen Ressourcen

Pods bieten zwei Arten von gemeinsam genutzten Ressourcen, nämlich Netzwerk und Speicher für die Container. Wenn Container in einem Pod mit Entitäten außerhalb des Pods kommunizieren, müssen sie koordinieren, wie sie die freigegebenen Netzwerkressourcen (z. B. Ports) verwenden. Innerhalb eines Pods kommunizieren Container über localhost eine IP-Adresse und einen Port.

Container innerhalb des Pods zeigen den Systemhostnamen als identisch mit dem für den Pod konfigurierten name Namen an.

Jeder Container in einem Pod kann den privilegierten Modus aktivieren, indem er das privileged Flag in der Containerspezifikation verwendet. Dies ist nützlich für Container, die administrative Funktionen des Betriebssystems benötigen, wie z. B. die Manipulation des Netzwerkstapels oder den Zugriff auf Hardwaregeräte. Prozesse innerhalb eines privilegierten Containers verfügen über nahezu die gleichen Berechtigungen, die Prozessen außerhalb eines Containers zur Verfügung stehen.

So zeigen Sie die Pod-Bereitstellung mit Ressourcen an:

  1. Erstellen Sie die crpd_res.yaml-Datei auf Kubernetes-primary und fügen Sie den folgenden Textinhalt hinzu:
  2. Speichern Sie die Datei crpd_res.yaml, um den crpd-Pod zu erstellen.

    root@kubernetes-master:~# kubectl create -f crpd_res.yaml

  3. Führen Sie den folgenden Befehl aus, um die Liste der vorhandenen Pods anzuzeigen:

    root@kubernetes-master:~# kubectl get pods

  4. Führen Sie den folgenden Befehl aus, um die Container im Pod und die Images anzuzeigen, die zum Erstellen verwendet wurden:

    root@kubernetes-master:~# kubectl describe pod crpres

cRPD-Pod-Bereitstellung mit bereitgestelltem Volume

An emptyDir ist ein Volume-Typ, der in Kubernetes unterstützt wird. Er wird erstellt, wenn ein Pod einem Knoten zugewiesen wird, und existiert so lange, wie der Pod auf diesem Knoten ausgeführt wird. Wie der Name schon sagt, ist das emptyDir Volume zunächst leer. Alle Container im Pod können die gleichen Dateien auf dem emptyDir Volume lesen und schreiben, obwohl dieses Volume in jedem Container an denselben oder unterschiedlichen Pfaden gemountet werden kann. Wenn ein Pod aus irgendeinem Grund von einem Knoten entfernt wird, werden die Daten im emptyDir Knoten dauerhaft gelöscht.

So zeigen Sie die cRPD-Podbereitstellung durch Einbinden des Speicherpfads in Kubernetes an:

  1. Erstellen der crpd_volume.yaml-Datei auf Kubernetes-primary Fügen Sie den folgenden Textinhalt hinzu:
  2. Speichern Sie die Datei crpd_volume.yaml, um den crpd-Pod zu erstellen.

    root@kubernetes-master:~# kubectl create -f crpd_volume.yaml

  3. Führen Sie den folgenden Befehl aus, um die Liste der vorhandenen Pods anzuzeigen:

    root@kubernetes-master:~# kubectl get pods

  4. Führen Sie den folgenden Befehl aus, um die Container im Pod und die Images anzuzeigen, die zum Erstellen verwendet wurden:

    root@kubernetes-master:~# kubectl describe pod crpd-volume

  5. Führen Sie den folgenden Befehl aus, um die cRPD-Instanz auszuführen:

    root@kubernetes-master:~# kubectl exec -it crpd-volume bash

  6. Führen Sie den folgenden Befehl aus, um die Dateien im Pfad anzuzeigen:

    root@crpd-volume:/# ls

  7. Führen Sie den folgenden Befehl aus, um zum Speicherpfad zu navigieren:

    root@crpd-volume:/# cd var/log/crpd-storage/

    root@crpd-volume:/var/log/crpd-storage/#