Konfigurieren der affinity- und nodeSelector-Regeln für Dynamic Engine

Verwenden Sie die nodeSelector- und affinity-Regeln in Dynamic Engine Helm-Charts, um die Pod-Planung über verschiedene Knotengruppen in Ihrem Kubernetes-Cluster hinweg zu steuern.

Ab Dynamic Engine v1.1.0 können Sie spezifische Affinitätsregeln festlegen, um Dienste auf bestimmten Knoten zu isolieren und damit Sicherheit, Leistung und Ressourcen zu optimieren. Beispielsweise können Sie eine große Knotengruppe für rechenintensive Pod-Ausführungen bestimmen.

Dynamic Engine v1.1.0 unterstützt sowohl nodeSelector-Regeln (einfache bezeichnungsbasierte Auswahl) und affinity-Regeln (komplexe Planungslogik) in Helm-Wertedateien.

Wichtig: Diese Anpassung kann während der anfänglichen Chart-Installation oder während eines Upgrades angewendet werden.

Vorbereitungen

Die benutzerdefinierten Ressourcendefinitionen dynamic-engine-crd müssen mit dem Helm-Chart oci://ghcr.io/talend/helm/dynamic-engine-crd installiert worden sein. Führen Sie andernfalls die folgenden Befehle für die Installation aus:
1. Suchen Sie die zu verwendende Diagrammversion:
  - Führen Sie den folgenden Helm-Befehl aus:
    helm show chart oci://ghcr.io/talend/helm/dynamic-engine-crd --version <engine_version>
  - Sehen Sie die Version direkt über Talend Management Console ein oder suchen Sie im Dynamic Engine Änderungs-Log nach der in Ihrer Dynamic Engine-Version enthaltenen Diagrammversion.
  - Verwenden Sie einen API-Aufruf an den Dynamic Engine-Versionsendpunkt.
2. Führen Sie den folgenden Befehl aus, um das Helm-Chart einer bestimmten Version zu installieren:
```
helm install dynamic-engine-crd oci://ghcr.io/talend/helm/dynamic-engine-crd --version <helm_chart_version>
```
  Ersetzen Sie <helm_chart_version> durch die Chart-Version, die von Ihrer Dynamic Engine-Version unterstützt wird.
  Wenn die Version nicht angegeben wird, installieren Sie die neueste verfügbare dynamic-engine-crd-Diagrammversion.
Ihr Kubernetes-Cluster muss mit mehreren Knotengruppen (Knotenpools) und entsprechenden Labels konfiguriert sein. Informationen zum Einrichten dieser Konfiguration finden Sie in der entsprechenden Dokumentation des Cloud-Providers. Wenn Sie z. B. Kubernetes mit GKE verwenden, finden Sie weitere Informationen unter Cluster- und Knotenpoollabels erstellen und verwalten.
Sie benötigen grundlegende Kenntnisse bezüglich Kubernetes-Affinitätsregeln.

Warum und wann dieser Vorgang ausgeführt wird

Standardmäßig werden Dynamic Engine Pods auf beliebigen verfügbaren Knoten im Cluster geplant. Mit Knotenaffinitäts- und Knotenauswahlregeln können Sie die Pod-Platzierung steuern, um spezifische Ziele zu erreichen. Sie können beispielsweise:

Dauerhafte Dienste auf kleineren, dedizierten Knoten isolieren
Arbeitslasten wie Jobs, Routen oder Datenservices auf größeren Knoten mit bestimmten Instanztypen ausführen

Die zu verwendenden Beispielknoten-Labels sind:

instanceType=large
instanceType=medium
qlik-dynamic-engine-tasks=true

Prozedur

Entpacken Sie auf dem Kubernetes-Rechner die Helm-Implementierungs-ZIP-Datei, die Sie zuvor heruntergeladen haben.
Erstellen Sie eine benutzerdefinierte Wertedatei unter Verwendung von nodeSelector für globale Planungsregeln.
Example
In diesem Beispiel ist eine globale Regel definiert, um dauerhafte Dienste für Infrastruktur auf mittelgroßen Knoten auszuführen. Mit dieser Regeln werden alle Dynamic Engine und Umgebungs-Pods auf Knoten mit dem Label instanceType=medium ausgeführt:
```
cat <<EOF > custom-medium-instance-for-infrastructure-values.yaml
global:
  nodeSelector:
    instanceType: medium
EOF
```
Der nodeSelector eignet sich für eine einfache genaue Übereinstimmung; logische Ausdrücke werden nicht unterstützt.
Alternativ können Sie eine benutzerdefinierte Wertedatei mithilfe von affinity-Regeln erstellen, um das gleiche Ergebnis mit komplexerer Planungslogik zu erzielen.
Example
In diesem Beispiel wird das gleiche Ergebnis wie mit nodeSelector erzielt, aber nodeAffinity verwendet:
```
cat <<EOF > custom-medium-instance-for-infrastructure-values.yaml
global:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: instanceType
                operator: In
                values: medium
EOF
```
InformationshinweisTipp: Die nodeSelector- und affinity-Regeln können kombiniert werden. Wenn Sie beide angeben, muss ein Knoten beide Regeln erfüllen, damit der Pod damit geplant werden kann.

Implementieren Sie die Dynamic Engine und Dynamic Engine Umgebung mit Ihren globalen Planungsregeln.

helm upgrade --install dynamic-engine-$DYNAMIC_ENGINE_ID -f $DYNAMIC_ENGINE_ID-values.yaml  \
 -f custom-medium-instance-for-infrastructure-values.yaml \
 oci://myregistry.example.com/docker-ghcr-io-remote/talend/helm/dynamic-engine \
 --version $DYNAMIC_ENGINE_VERSION

helm upgrade --install dynamic-engine-environment-$DYNAMIC_ENGINE_ENVIRONMENT_ID -f $DYNAMIC_ENGINE_ENVIRONMENT_ID-values.yaml  \
 -f custom-medium-instance-for-infrastructure-values.yaml \
 oci://myregistry.example.com/docker-ghcr-io-remote/talend/helm/dynamic-engine-environment \
 --version $DYNAMIC_ENGINE_VERSION

Erstellen Sie zur arbeitslastspezifischen Planung eine weitere benutzerdefinierte Wertedatei, um die Pod-Ausführungen in einer großen Knotengruppe einzuschränken.
Example
In diesem Beispiel wird eine spezifische Regel definiert, um Datenintegrationsaufgaben und Datenservice- und Routen-Aufgaben auf große Knoten mit der Bezeichnung qlik-dynamic-engine-tasks=true zu beschränken:
```
cat <<EOF > custom-jobDeployment-dataServiceRouteDeployment-nodeSelector-values.yaml
configuration:
  jobDeployment:
    nodeSelector:
      instanceType: large
      qlik-dynamic-engine-tasks: "true"
  dataServiceRouteDeployment:
    nodeSelector:
      instanceType: large
      qlik-dynamic-engine-tasks: "true"
EOF
```

Implementieren Sie die Dynamic Engine Umgebung mit arbeitslastspezifischen Planungsregeln.

Example

Diese Arbeitslastregel ist für die Aufgabenverarbeitungsdienste spezifisch und wird daher nur auf eine Dynamic Engine Umgebung angewendet.

helm upgrade --install dynamic-engine-environment-$DYNAMIC_ENGINE_ENVIRONMENT_ID \
 -f $DYNAMIC_ENGINE_ENVIRONMENT_ID-values.yaml  \
 -f custom-jobDeployment-dataServiceRouteDeployment-nodeSelector-values.yaml \
 oci://myregistry.example.com/docker-ghcr-io-remote/talend/helm/dynamic-engine-environment \
 --version $DYNAMIC_ENGINE_VERSION

Ergebnisse

Nach der erfolgreichen Implementierung werden alle Dynamic Engine und Umgebungs-Pods entsprechend Ihrer benutzerdefinierten affinity- und nodeSelector-Regeln geplant. Dauerhafte Dienste für die Infrastruktur werden auf ihren designierten Knoten ausgeführt, und Kundenarbeitslasten werden auf Knoten ausgeführt, die für die entsprechenden Ressourcenanforderungen optimiert sind.

Troubleshooting:

Wenn ein oder mehrere Pods nicht auf einem Knoten geplant werden können, verwenden Sie die folgenden Schritte, um das Problem zu diagnostizieren und zu beheben.

Identifizieren Sie den Planungsfehler:
Verwenden Sie den Befehl kubectl describe pod, um detaillierte Informationen über den Planungsfehler zu erhalten:
```
kubectl describe pod <pod-name> -n <namespace>
```
Suchen Sie nach dem Abschnitt Events (Ereignisse), der Hinweise auf die Gründe für den Planungsfehler enthält. Zu häufigen Gründen zählen:
- Regeln, die keinen Knoten entsprechen
- Unzureichende CPU- oder Arbeitsspeicherressourcen auf verfügbaren Knoten
- Taint- und Toleration-Probleme auf Knoten, die eine Pod-Planung verhindern
Überprüfen Sie Regeln:
Vergewissern Sie sich, dass die Knoten über die erforderlichen, in Ihren Regeln angegebenen Labels verfügen:
```
kubectl get nodes --show-labels
```
Vergleichen Sie die Labels auf Ihren Knoten mit den Labels, die in Ihren Wertedateien angegeben sind.
Überprüfen Sie Ressourcenbeschränkungen:
Einer der häufigsten Gründe für Planungsfehler sind ungenügende Ressourcen (CPU, Arbeitsspeicher). Überprüfen Sie die Ressourcenanforderungen und Limits in Ihren Pods:
```
kubectl describe nodes
```
Wenn Ihr Cluster nicht über genügend Knoten zum Erfüllen von Ressourcenanforderungen verfügt, skalieren Sie den Cluster hoch, um weitere Knoten hinzuzufügen.
Überprüfen Sie die Taint- und Toleration-Spezifikationen in den designierten Knoten.
Taints können verhindern, dass Knoten bestimmte Pods planen. Wenn Ihre Knoten Taints aufweisen und Ihre Pods nicht über entsprechende Tolerations verfügen, können die Pods nicht geplant werden. Weitere Informationen zu Taints und Tolerations von Kubernetes finden Sie unter Taints und Tolerations.

Dynamic Engine unterstützt derzeit keine Taints und Tolerations in Helm-Charts. Wenn Sie Knoten mit Taints haben, müssen Sie entweder die Taints entfernen oder eine andere Knotengruppe für die Dynamic Engine Implementierung verwenden.

Hat diese Seite Ihnen geholfen?

Wenn Sie ein Problem mit dieser Seite oder ihrem Inhalt feststellen, sei es ein Tippfehler, ein ausgelassener Schritt oder ein technischer Fehler, informieren Sie uns bitte!

Geben Sie hier Ihr Feedback ab