Herunterladen des Kubernetes-Inventarisierungsagenten von Flexera

FlexNet Manager Suite 2024 R2 (Standortgebundene Implementierung)

Der Flexera-Kubernetes-Inventarisierungsagent dient dazu, die Inventarisierung in Kubernetes-Clustern zu handhaben. Um den Kubernetes-Inventarisierungsagenten von Flexera für mindestens einen Kubernetes-Cluster einzusetzen, müssen Sie ihn in der OCI-Container-Registry (der Bibliothek oder Bibliothekensammlung, die zum Hinterlegen von Containerimages verwendet wird, die der Open Container Initiative entsprechen) verfügbar machen. Bitten Sie für den folgenden Vorgang Ihre(n) Kubernetes-Administrator(en) um Unterstützung.

Außerdem verlangt die Infrastruktur für FlexNet Manager Suite, dass der Flexera-Kubernetes-Inventarisierungsagent nach der Installation in der Lage ist, Inventardateien (.ndi) auf eine Inventarisierungsstation hochzuladen. Diese Inventarisierungsstation muss anschließend Dateien an den zentralen Anwendungsserver hochladen können. Legen Sie die URL der Inventarisierungsstation fest, die vom Kubernetes-Inventarisierungsagenten von Flexera in Ihrem (ersten) Kubernetes-Cluster verwendet werden soll, und halten Sie den Wert zur Verwendung im nachfolgenden Vorgang griffbereit.

Tipp: Wenn der FlexNet-Inventarisierungsagent zur Sammlung von Software-Inventar in Containern in diesen bereitgestellt wird, benötigt er keinen direkten Zugang zu einer Inventarisierungsstation. In diesem Fall werden die .ndi-Inventardateien aus den Containern herauskopiert und vom Kubernetes-Inventarisierungsagenten von Flexera zusammen mit den anderen, von ihm erzeugten .ndi-Dateien hochgeladen.

So gehen Sie vor, um den Kubernetes-Inventarisierungsagenten von Flexera herunterzuladen und zu installieren:

Melden Sie sich bei einem Gerät an, das:
- eine unterstützte Linux-Version ausführt
- über einen Web-Browser mit Netzwerkzugriff auf den Webanwendungsserver für FlexNet Manager Suite verfügt, wo Ihr Konto über Operatorrechte verfügen muss, um die entsprechende Seite einsehen zu können
- eine laufende Docker-Instanz aufweist
- entweder eine OCI-Container-Registry hostet oder Netzwerkzugriff auf eine OCI-Container-Registry hat, die in Ihrem Kubernetes-Cluster verfügbar ist
Tipp: Der Vorgang ist einfacher, wenn Sie sich bei diesem Gerät mit einem Konto anmelden, das über administrative Berechtigungen für Ihre OCI-Container-Registry und auch für den Kubernetes-Cluster verfügt (anderenfalls müssen Sie während des Vorgangs Daten zwischen verschiedenen Konten verschieben). Während der Installation muss das Konto Berechtigungen zum Erstellen der folgenden Arten von Ressourcen aufweisen:
- Namespace
- ServiceAccount
- ClusterRole
- ClusterRoleBinding
- Deployment
Der Installationsvorgang erstellt die Konten und Berechtigungen, die zum Betreiben des Flexera-Kubernetes-Inventarisierungsagenten und ndtrack.sh (wenn es aufgerufen wird, um Inventar innerhalb eines Containers zu erfassen) benötigt werden.
Navigieren Sie in Ihrem Web-Browser in FlexNet Manager Suite zu Ermittlung & Inventarisierung > Einstellungen.
Die Seite Inventarisierungseinstellungen wird aufgerufen.
Erweitern Sie den Abschnitt Inventarisierungsagent zum Herunterladen.
Klicken Sie auf Flexera-Kubernetes-Inventarisierungsagent herunterladen und speichern Sie die heruntergeladene Archivdatei an einem geeigneten Ort.
Extrahieren Sie aus dem heruntergeladenen Archiv das Image für den Kubernetes-Inventarisierungsagenten von Flexera zum Beispiel mit der folgenden Befehlszeile (ersetzen Sie den Platzhalter x.y.z durch die entsprechende Versionsnummer – bei der Version 2022 R2 sind dies die Ziffern 1.7.0):
```
tar xzf flexera-krm-operator-x.y.z.tar.gz
```
Anmerkung: Die Versionsnummern in diesem Befehl sind die Versionsnummern für den Kubernetes-Inventarisierungsagenten von Flexera, den Sie heruntergeladen haben, was sich im Namen des heruntergeladenen Archivs widerspiegelt. Denken Sie daran, dass das heruntergeladene Image auch die Kerninventarisierungskomponente des FlexNet-Inventarisierungsagenten (ndtrack.sh) enthält, die ihre eigene abweichende Versionsnummer hat. Wenn der Pod des Kubernetes-Inventarisierungsagenten von Flexera zum ersten Mal in einem Kubernetes-Knoten ausgeführt wird, fragt er als Erstes die ihm zugewiesene Inventarisierungsstation nach der neuesten Richtlinie mit Ihren Einstellungen unter Ermittlung & Inventarisierung > Einstellungen > Inventarisierungsagent für automatische Bereitstellung > Bereitzustellende Version. Wenn Ihre für den FlexNet-Inventarisierungsagenten ausgewählte Version nicht mit der aus dem heruntergeladenen Image übereinstimmt, lädt der Pod die angegebene Version herunter und verwendet anschließend diese Version von ndtrack.sh zur Erfassen von Software-Inventar von anderen Pods auf dem Knoten. (Wenn Sie nicht möchten, dass sich der Flexera-Kubernetes-Inventarisierungsagent an Ihre Einstellungen auf der Weboberfläche hält, sondern wenn er stattdessen die Version von ndtrack.sh verwenden soll, die im archivierten Image enthalten ist, das Sie gerade heruntergeladen haben, bitten Sie Ihren Kubernetes-Administrator, die Voreinstellung von downloadFromBeacon wie unter Erweiterte Attribute für den Kubernetes-Inventarisierungsagenten von Flexera beschrieben zu ändern.)
Gehen Sie in das Verzeichnis, das aus dem Archiv extrahiert wurde:
```
cd flexera-krm-operator-x.y.z
```
Tipp: Das extrahierte Image enthält mehrere grundlegende YAML-Dateien, das Skript generate.sh zum Erstellen Ihrer eigenen YAML-Datei mit der Definition Ihrer Installation und das Shell-Skript install.sh, das später zur Installation des sich ergebenden Operators in einem Kubernetes-Cluster benötigt wird.
Die extrahierte Verzeichnisstruktur sieht folgendermaßen aus. Verzeichnisse mit dem Suffix „aarch64“ oder „s390x“ im Namen gehören zur x86_64-Architektur; Verzeichnisse mit dem Suffix „aarch64“ gehören zur aarch64/arm64-Architektur; und Verzeichnisse mit dem Suffix „s390x“ gehören zur s390x-Architektur (auch unter der Bezeichnung „System z“ oder „z/Architecture“ bekannt).
```
|-> imgtrack-a.b.c
|-> imgtrack-a.b.c-aarch64
|-> imgtrack-a.b.c-s390x
|-> krm-d.e.f
|-> krm-d.e.f-aarch64
|-> krm-d.e.f-s390x
|-> lwk-g.h.i
|-> lwk-g.h.i-aarch64
|-> lwk-g.h.i-s390x
```
Wenn Sie in einer x86_64-Architektur arbeiten, gehen Sie in das Verzeichnis krm-d.e.f. Wenn Sie in einer aarch64/arm64-Architektur arbeiten, gehen Sie in das Verzeichnis krm-d.e.f-aarch64. Wenn Sie in einer s390x-Architektur arbeiten, gehen Sie in das Verzeichnis krm-d.e.f-s390x.
```
cd krm-d.e.f
```
oder
```
cd krm-d.e.f-aarch64
```
oder
```
cd krm-d.e.f-s390x
```
Importieren Sie das extrahierte Image in Docker:
```
docker load < flexera-krm-x.y.z.tar
```
Anmerkung: Es darf nur eine krm-Architektur importiert werden.
Setzen Sie neue Tags im Image für Ihre Registry.
Tipp: Wenn Sie mehrere Container-Registrys haben, führen Sie den Vorgang für jede einzelne zu Ende und kehren Sie dann zurück, um den Vorgang ab diesem Punkt für die nächste Registry zu wiederholen.
In diesen Beispielen wird die OCI-Container-Registry mit images.example.com dargestellt, was Sie durch die URL Ihrer eigenen Registry ersetzen.
Wichtig: Der Image-Namensbbestandteil flexera/krm darf nicht geändert werden. Setzen Sie wie gezeigt Ihre Registry-URL einfach vor diese Zeichenfolge.
```
docker tag flexera/krm:x.y.z images.example.com/flexera/krm:x.y.z
```
Vergewissern Sie sich, dass Sie bei Ihrer OCI-Container-Registry angemeldet sind und ein Konto nutzen, das über administrative Rechte verfügt.
Schieben Sie das Image für den Kubernetes-Inventarisierungsagenten von Flexera in Ihre Registry:
```
docker push images.example.com/flexera/krm:x.y.z
```
Es ist nur ein Containerimage erforderlich, da dieses vom Controller und allen Komponenten des Kubernetes-Inventarisierungsagenten von Flexera gemeinsam genutzt wird.
Tipp: Wenn sich das Containerimage in der OCI-Container-Registry befindet, kann der Controller übereinstimmende Container im Kubernetes-Cluster instanziieren. Wenn das Image vor der Installation jedoch nicht in eine zugängliche Registry geschoben wurde, wird eine Bereitstellung der Controller-Pods (am Ende dieses Vorgangs) scheitern. Abhilfe: Wenn dieser Fehler auftritt, können Sie das Containerimage auch noch nach Bereitstellung des Controllers in die Registry schieben. Der Pod wird in regelmäßigen Abständen versuchen, das Image erneut zu holen. Sie können den Vorgang beschleunigen, indem Sie den Pod selbst löschen. Das ReplicaSet, das den Pod automatisch verwaltet, erstellt den Pod neu und beginnt sofort erneut damit, das Image zu holen.
Legen Sie fest, wie Sie permanenten Speicherplatz für den Kubernetes-Inventarisierungsagenten von Flexera bereitstellen möchten.
Das vom Kubernetes-Inventarisierungsagenten von Flexera verwendete StatefulSet erfordert einen PersistentVolumeClaim (PVC), der seine Speicherkonfiguration definiert. Es gibt folgende Voraussetzungen für den Speicher:
- Das Volume bleibt auch bei Neustarts und Upgrades des Kubernetes-Pods, der den Flexera-Kubernetes-Inventarisierungsagenten enthält, bestehen (es ist beständig/verlässlich).
- Das Volume wird nicht gemeinsam mit anderen Ressourcen im Cluster genutzt.
- Ein Minimum von 2 GB Speicherplatz ist verfügbar.
- Der Zugriffsmodus muss ReadWriteOnce lauten (dies ist der Standardwert für Controller).
- Der Volume-Modus muss Filesystem lauten (ebenfalls der Standardwert für Controller).
Alle Konfigurationen, die diese Voraussetzungen erfüllen, sind gültig. Als Nächstes deklarieren Sie das Ergebnis Ihrer Speicherentscheidung in der YAML-Datei. Weitere Informationen zum Festlegen des permanenten Speichers finden Sie unter https://kubernetes.io/docs/concepts/storage/persistent-volumes/#persistentvolumeclaims.
Konfigurieren Sie kubectl korrekt, um sich unter Verwendung des entsprechenden Kontos mit administrativen Rechten für den Cluster mit dem richtigen Cluster zu verbinden. Beispiel:
```
kubectl config set-context cluster-one --user=administrator
```
Dies konfiguriert kubect1 so, dass sich nachfolgende Befehle (insbesondere der Befehl kubectl apply, der später vom Installationsskript verwendet wird) auf den Cluster beziehen, der vom cluster-one-Kontext definiert wurde, und den administrator-Benutzer verwenden.
Suchen Sie im erweiterten Archiv, das Sie zuerst heruntergeladen haben, das Skript install.sh.
Das Installationsskript verwendet den Befehl kubectl zur Kommunikation mit dem Kubernetes-Cluster.
Wenn das Installationsskript ausgeführt wird, erstellt es den Operator für den Kubernetes-Inventarisierungsagenten von Flexera.
Tipp: In Kubernetes ist ein Operator ein Controller, der das Kubernetes-API mithilfe von benutzerdefinierten Ressourcen erweitert, um eine Anwendung und ihre Komponenten zu verwalten.
Dazu erstellt das Installationsskript die folgenden Ressourcen im Kubernetes-Cluster:
1. die krms.agents.flexera.com CustomResourceDefinition
2. den flexera Namespace
3. einen ServiceAccount im flexera Namespace für den Controller
4. einen ServiceAccount im flexera Namespace für den Kubernetes-Inventarisierungsagenten von Flexera
5. eine ClusterRole, die die vom Controller benötigten Berechtigungen definiert, und eine ClusterRoleBinding, um diese ClusterRole mit dem ServiceAccount des Controllers zu verbinden
6. eine ClusterRole, die die vom Kubernetes-Inventarisierungsagenten von Flexera benötigten Berechtigungen definiert
7. ClusterRoleBindings, die die Agenten-ClusterRole und die integrierte Ansichts-ClusterRole mit dem ServiceAccount des Agenten verbinden
8. eine Bereitstellung (Deployment) der Controller-Anwendung im flexera Namespace.
Installieren Sie den Kubernetes-Operator oder den Kubernetes-OLM-(Operator-Lifecycle-Manager-)Operator.

Anmerkung: https://gallery.ecr.aws/flexera/krm wird vom Flexera-krm-OLM-Agenten genutzt – es kann auch in Option A verwendet werden. Das Image kann von https://gallery.ecr.aws/flexera/krm mit der Versions-Tag-Nummer (zum Beispiel „docker pull public.ecr.aws/flexera/krm:1.6.8”) abgerufen werden.

Anmerkung: https://gallery.ecr.aws/flexera/lwk hat keinen Bezug zum Flexera-krm-OLM-Agenten – es ist für eine Verwendung wie etwa durch den Kubernetes-Kompaktagenten verfügbar, der aktuell ausgeliefert wird. Weitere Informationen finden Sie unter Herunterladen des Kubernetes-Kompaktagenten. Das Image kann von https://gallery.ecr.aws/flexera/lwk mit der Versions-Tag-Nummer (zum Beispiel „docker pull public.ecr.aws/flexera/lwk:1.5.4“) abgerufen werden.
- Option A: Zur Installation des Kubernetes-Operators führen Sie das Skript install.sh mit den entsprechenden (hier beschriebenen) Parametern aus.
  Es gibt einen Pflichtparameter und zwei bedingte Parameter für das Installationsskript.
  - Obligatorisch: Die --registry-Option identifiziert Ihre OCI-Container-Registry für diesen Kubernetes-Cluster und lässt das Installationsskript die YAML-Datei aktualisieren, indem es die aktuelle Registry der Spezifikation des Containerimage voranstellt (genau wie beim Image-Import weiter oben). (Ohne dass dieser Parameter an das Installationsskript übergeben wird, schlägt die Bereitstellung des Controller-Pods später im Vorgang fehl). Beispiel für eine Befehlszeile mit dem gleichen Platzhalter wie vorher:
    ./install.sh --registry images.example.com
  - Bedingt: Wenn Sie möchten, dass sich Ihr Flexera-Kubernetes-Inventarisierungsagent mit dem IBM-Lizenzservice integriert, insbesondere zur Verwaltung der VPC- und PVU-Sub-Capacity-Lizenzierung für eigenständige Produkte oder Pakete (Bundles) wie IBM Cloud Paks, müssen Sie den Parameter --ibm-licensing aufnehmen. Kumulative Musterbefehlszeile:
    ./install.sh --registry images.example.com --ibm-licensing
  - Bedingt: Wenn Sie möchten, dass Ihr Flexera-Kubernetes-Inventarisierungsagent auf der OpenShift-Plattform (von Red Hat) ausgeführt wird, müssen Sie den Parameter --openshift aufnehmen. Auf dieser Plattform muss der Container für den Kubernetes-Inventarisierungsagenten von Flexera als Root-Benutzer ausgeführt werden. Diese Option erstellt einen geeigneten SecurityContextConstraints-Eintrag und verknüpft diesen mit dem ServiceAccount für den Kubernetes-Inventarisierungsagenten von Flexera. Kumulative Musterbefehlszeile:
    ./install.sh --registry images.example.com --ibm-licensing --openshift
  Wenn sich Ihre Situation für diesen Kubernetes-Cluster ändert, können Sie das Installationsskript mit den dann geltenden Parametern erneut ausführen. Dadurch wird Ihre vorherige Installation durch eine neue überschrieben, die Ihre neuen Anforderungen erfüllt.
  Weitere Informationen finden Sie in der Hilfe, die mit dem Installationsskript zur Verfügung gestellt wird.
```
./install.sh --help
```
  Sie können auch in der README.md-Datei nachsehen, die im heruntergeladenen Archiv für den Kubernetes-Inventarisierungsagenten von Flexera enthalten ist.
- Option B: Zur Installation des Kubernetes-OLM-Operators führen Sie das Skript olm-install.sh mit den entsprechenden (hier beschriebenen) Parametern aus.
  Für dieses Installationsskript gibt es drei bedingte Parameter.
  - Bedingt: Wenn Sie lieber oc statt kubectl verwenden möchten, müssen Sie den Parameter --oc-as-kubectl setzen. Kumulative Musterbefehlszeile:
```
./olm-install.sh --oc-as-kubectl
```
  - Bedingt: Wenn Sie Ihren Kubernetes-OLM-Inventarisierungsagenten von Flexera mit dem IBM-Lizenzservice integrieren möchten, insbesondere zur Verwaltung der VPC- und PVU-Sub-Capacity-Lizenzierung für eigenständige Produkte oder Pakete (Bundles) wie IBM Cloud Paks, müssen Sie den Parameter --ibm-licensing setzen. Kumulative Musterbefehlszeile:
```
./olm-install.sh --ibm-licensing --ibm-licensing-rbac
```
  - Bedingt: Wenn Sie möchten, dass Ihr Kubernetes-OLM-Inventarisierungsagent von Flexera auf der OpenShift-Plattform (von Red Hat) ausgeführt wird, müssen Sie den Parameter --openshift setzen. Auf dieser Plattform muss der Container für den Kubernetes-OLM-Inventarisierungsagenten von Flexera als Root-Benutzer ausgeführt werden. Diese Option erstellt einen geeigneten SecurityContextConstraints-Eintrag und verknüpft diesen mit dem ServiceAccount für den Kubernetes-OLM-Inventarisierungsagenten von Flexera. Kumulative Musterbefehlszeile:
```
./olm-install.sh --ibm-licensing --ibm-licensing-rbac --openshift
```
  Wenn sich Ihre Situation für diesen Kubernetes-Cluster ändert, können Sie das Installationsskript mit den dann geltenden Parametern erneut ausführen. Dadurch wird Ihre vorherige Installation durch eine neue überschrieben, die Ihre neuen Anforderungen erfüllt.
  Weitere Informationen finden Sie in der Hilfe, die mit dem Installationsskript zur Verfügung gestellt wird.
```
./olm-install.sh --help
```

Führen Sie aus dem erweiterten Archiv, das Sie zuerst heruntergeladen haben, das Skript generate.sh aus.

./generate.sh

Die ist ein interaktives Skript, das alle Optionen für eine YAML-Datei zur Definition der von Ihnen benötigten Konfiguration des Kubernetes-Inventarisierungsagenten von Flexera präsentiert. Für jede Option können Sie, nachdem Sie sich die Beschreibung durchgelesen haben, entscheiden, ob Sie den Standardwert akzeptieren oder Ihren eigenen bevorzugten Wert zur Konfiguration des entsprechenden Elements eingeben. Diese Werte werden vom Controller gelesen und verwendet, um den Kubernetes-Inventarisierungsagenten von Flexera sowohl bei der ersten Bereitstellung als auch nach eventuell erforderlichen Korrekturen am Laufstatus korrekt zu konfigurieren. Für die meisten Werte in der YAML-Datei gibt es sinnvolle Voreinstellungen, sodass nur zwei Änderungen wie hier beschrieben verpflichtend sind.

Anmerkung: Derzeit wird nur ein einziger Flexera-Kubernetes-Inventarisierungsagent für einen bestimmten Cluster unterstützt. Das bedeutet Folgendes: Wenn in einem Cluster bereits ein Flexera-Kubernetes-Inventarisierungsagent aktiv ist, müssen Sie die Konfigurationsdetails für den Agenten in Ihre vorhandene Konfiguration übernehmen, anstatt einfach nur eine neue YAML-Datei anzulegen. Sie können den Bearbeitungsvorgang manuell abschließen, wenn Sie wissen wie. Die Nutzung des Skripts generate.sh ist nicht verpflichtend. Weitere Informationen zur Konfigurationsstruktur und den optionalen Attributen finden Sie unter Ändern der Konfiguration für den Kubernetes-Inventarisierungsagenten von Flexera.

Die beiden kundenspezifischen Pflichtwerte sind:

Die URL der Inventarisierungsstation, auf die die beiden Agenten in diesem Kubernetes-Cluster zugreifen.

Attribut	`spec.monitor.beaconURL`
Typ	String
Beispiel	`https://beacon.example.org`

Die Konfiguration, die Sie für den permanenten Speicher für den Kubernetes-Inventarisierungsagenten von Flexera wählen:

Attribut	`spec.monitor.storage`
Typ	`PersistentVolumeClaimSpec`

Tipp: Wenn Sie zuvor entweder den Zugriffsmodus oder den Volume-Modus den eigenen Vorgaben entsprechend angepasst haben, stellen Sie auch für diese die Standardwerte wie oben beschrieben wieder her.

Wenn die Bearbeitung abgeschlossen ist, speichern Sie die YAML-Datei an einem Ort, an dem der Befehl kubectl darauf zugreifen kann (nächstes Thema). Sie können einen bevorzugten Namen vergeben, wie z. B. fkia.yaml, nur müssen Sie im nächsten Schritt auf den korrekten Namen verweisen. (Der Vorgabewert krm.yaml steht für „Kubernetes-Ressourcen-Monitor“.)

Wenden Sie Ihre vorbereitete YAML-Datei auf den Cluster an (setzen Sie im Befehl den von Ihnen gewählten Namen der YAML-Datei ein):
```
kubectl apply -f fkia.yaml
```

Wenn dieser Vorgang einen Erfolg meldet, ist Ihr Flexera-Kubernetes-Inventarisierungsagent installiert und in diesem Cluster einsatzbereit. Außerdem ist der Controller initialisiert, um den gewünschten Zustand beizubehalten. Wiederholen Sie für weitere Kubernetes-Cluster diesen Vorgang und modifizieren Sie dabei dem jeweiligen Cluster entsprechend die Parameter.

FlexNet Manager Suite (Standortgebundene Implementierung)

2024 R2