Déployez SuperLink à l’aide de Helm

Note

Flower Helm charts are a Flower Enterprise feature. See Flower Enterprise for details.

Le cadre de référence Flower offre une approche unifiée pour l’apprentissage fédéré, les analyses et l’évaluation, vous permettant de faire participer tout type de charge de travail, framework d’apprentissage automatique ou langage de programmation.

Ce chart d’installation installe les composants côté serveur du cadre de référence Flower, en particulier en configurant le SuperLink.

La configuration d’installation par défaut vise à reproduire la fonctionnalité et la mise en place des sorties officielles du cadre de référence Flower.

Désactivez le composant SuperLink

superlink:
  name: superlink
  enabled: false

Activez le composant SuperExec

superexec:
  enabled: true

Exécutez des simulations dans Kubernetes à l’aide du Plugin de Simulation

Pour plus d’informations, consultez la guide sur l’exécution de simulations.

superlink:
  enabled: true
  simulation:
    enabled: true

Change Log Verbosity Level

Le niveau de verbosité du journal dans Flower peut être ajusté en utilisant la variable d’environnement FLWR_LOG_LEVEL. Cela aide à contrôler le niveau de détail inclus dans les journaux, facilitant ainsi la débogage et la surveillance.

Setting Global Log Level

Pour activer une mise en forme détaillée (par exemple, au niveau DEBUG) pour tous les services, ajoutez FLWR_LOG_LEVEL à la section env sous la section global dans votre fichier values.yml :

global:
  env:
    - name: FLWR_LOG_LEVEL
      value: DEBUG

Setting Log Level for a Specific Service

Si vous souhaitez activer uniquement la mise en forme pour un service spécifique (par exemple, superlink), vous pouvez le spécifier sous la section respective :

superlink:
  env:
    - name: FLWR_LOG_LEVEL
      value: DEBUG

Pour plus de détails sur la configuration des journaux, consultez : Flower Logging Documentation

Configurez l’enregistrement des audits

La journalisation d’audit fournit un sortie de log au format JSON pour Flower, vous permettant de capturer et de stocker les événements qui se produisent dans le SuperLink. Cette fonctionnalité est utile pour la surveillance, le débogage ou la tenue d’un historique des actions importantes.

Pour activer la journalisation d’audit, ajoutez la suivante flag à la configuration du SuperLink :

superlink:
  enabled: true
  extraArgs:
    - --enable-event-log

Pour plus de détails sur la configuration de la journalisation d’audit, consultez : Flower Audit Logging Documentation

Clé de Licence

À partir de 1.20.0, le service SuperLink doit être démarré avec une clé de licence valide.

Vous pouvez configurer la clé de licence dans la section global.license de votre fichier values.yml d’une des deux manières :

1. Directement — en définissant global.license.key sur votre clé de licence.

2. À partir d’un secret existant Kubernetes — en définissant global.license.existingSecret sur le nom d’un secret qui contient votre clé.

Note

Le SuperLink doit être capable de se connecter à https://api.flower.ai pour valider la licence.

Exemple : Définition directe de la clé de licence

global:
  license:
    enabled: true
    key: <YOUR_FLWR_LICENSE_KEY>
    existingSecret: ""

Dans cette configuration, le chart Helm créera automatiquement un secret Kubernetes et l’injectera dans le conteneur du SuperLink.

Exemple : Utilisation d’un secret existant

global:
  license:
    enabled: true
    key: ""
    existingSecret: "existing-license-key-secret"

Si les deux key et existingSecret sont définis, existingSecret a la priorité et la valeur key sera ignorée.

Note

Par défaut, le ressource existingSecret doit contenir une clé nommée FLWR_LICENSE_KEY.

kind: Secret
stringData:
  FLWR_LICENSE_KEY: <YOUR_FLWR_LICENSE_KEY>

Exemple : Définition d’une clé de secret personnalisée

Si vous préférez utiliser un nom de clé différent du par défaut FLWR_LICENSE_KEY, vous pouvez le surcharger en définissant secretKey sur votre nom souhaité :

global:
  license:
    enabled: true
    key: ""
    secretKey: "license-key"
    existingSecret: "existing-license-key-secret"

kind: Secret
stringData:
  license-key: <YOUR_FLWR_LICENSE_KEY>

Activer l’authentification des comptes

L’authentification des comptes peut être activée si vous utilisez les images Docker de l’édition Entreprise (EE) de Flower. Cela est configuré dans la section global.userAuth de votre fichier values.yml.

Exemple : Activation de l’authentification OpenID Connect (OIDC)

global:
  userAuth:
    enabled: true
    config:
      authentication:
        authn_type: oidc
        authn_url: https://<domain>/auth/device
        token_url: https://<domain>/token
        validate_url: https://<domain>/userinfo
        oidc_client_id: <client_id>
        oidc_client_secret: <client_secret>

Explication des paramètres :

• authn_type: Le mécanisme d’authentification utilisé (par exemple, oidc).

• authn_url: L’endpoint d’authentification OpenID Connect où les utilisateurs s’authentifient.

• token_url: L’URL pour récupérer des jetons d’accès.

• validate_url: L’endpoint pour valider l’authentification des comptes.

• oidc_client_id: Le client ID émis par le fournisseur d’authentification.

• oidc_client_secret: La clé secrète associée à l’ID client.

Utiliser un Secret Existant

Pour utiliser un secret existant qui contient la configuration d’authentification de compte, définissez existingSecret sur le nom du secret existant:

global:
  userAuth:
    enabled: true
    config: {}
    existingSecret: "existing-account-auth-config"

Notez que le secret existant doit contenir la clé account-auth-config.yml:

kind: Secret
stringData:
  account-auth-config.yml: |
    authentication:
      authn_type: oidc
      authn_url: https://<domain>/auth/device
      token_url: https://<domain>/token
      validate_url: https://<domain>/userinfo
      oidc_client_id: <client_id>
      oidc_client_secret: <client_secret>

Configuration d’OpenFGA

Le composant de chart Flower Server prend en charge OpenFGA comme service d’autorisation fine-grainée, mais il est désactivé par défaut.

Pour activer OpenFGA, modifiez la valeur suivante dans votre fichier values.yml:

openfga:
  enabled: true

Par défaut, OpenFGA exécutera avec un stockage en mémoire, qui n’est pas persistant et convient uniquement pour les tests ou le développement.

OpenFGA prend en charge le stockage persistant à l’aide de PostgreSQL ou MySQL:

• Pour déployer OpenFGA avec une nouvelle instance PostgreSQL/MySQL, activez la configuration de chart bundlée.

• Pour se connecter à une base de données existante, fournez les détails de connexion appropriés via les valeurs Helm (par exemple, openfga.datastore.uri).

Pour en savoir plus, visitez la documentation officielle du Chart Helm d’OpenFGA.

Les commandes suivantes configureraient un stockage, un modèle d’autorisation et insèrent des utilisateurs (en utilisant des tuples) dans OpenFGA. Exécutez-les une fois l’instance OpenFGA déployée.

Configurez le modèle d’autorisation et les tuples:

Fichier de modèle model.fga

model
  # We are using the 1.1 schema with type restrictions
  schema 1.1

# Define the 'flwr_aid' type to represent individual users in the system.
type flwr_aid

# Define the 'service' type to group users.
type service
  relations
    # The 'has_access' relation defines users who have access to this service.
    define has_access: [flwr_aid]

Fichier de permissions utilisateur tuples.yaml

- user: flwr_aid:<OIDC_SUB_1>
  relation: has_access
  object: service:<your_grid_name>
- user: flwr_aid:<OIDC_SUB_2>
  relation: has_access
  object: service:<your_grid_name>

Créer un stockage:

OPENFGA_URL="<OPENFGA_URL>"
OPENFGA_STORE_NAME="<OPENFGA_STORE_NAME>"
docker run --rm -v "$(pwd)":/app -w /app openfga/cli \
  --api-url ${OPENFGA_URL} store create \
  --name ${OPENFGA_STORE_NAME}

La réponse inclura un champ id, qui est l’ID du stockage OpenFGA associé à la valeur OPENFGA_STORE_NAME créée.

Obtenir l’ID du stockage (méthode alternative):

docker run --rm -v "$(pwd)":/app -w /app openfga/cli \
  --api-url ${OPENFGA_URL} store list

Définissez l’ID du stockage OpenFGA de l’étape précédente et écrivez le modèle:

OPENFGA_STORE_ID="<STORE_ID_FROM_EARLIER_STEP>"
docker run --rm -v "$(pwd)":/app -w /app openfga/cli \
  --api-url ${OPENFGA_URL} model write \
  --store-id ${OPENFGA_STORE_ID} \
  --file model.fga

Définissez l’ID du modèle OpenFGA de l’étape précédente et écrivez les tuples:

OPENFGA_MODEL_ID="<MODEL_ID_FROM_EARLIER_STEP>"
docker run --rm -v "$(pwd)":/app -w /app openfga/cli \
  --api-url ${OPENFGA_URL} tuple write \
  --store-id ${OPENFGA_STORE_ID} \
  --model-id ${OPENFGA_MODEL_ID} \
  --file tuples.yaml

Ajoutez une nouvelle section authorization sous votre configuration global.userAuth existante ou directement dans votre secret existant, en fonction de votre configuration. Définissez la valeur OPENFGA_STORE_ID et OPENFGA_MODEL_ID des étapes précédentes dans le fichier:

authorization:
  authz_type: openfga
  authz_url: <OPENFGA_URL>
  store_id: <OPENFGA_STORE_ID>
  model_id: <OPENFGA_MODEL_ID>
  relation: has_access
  object: service:<your_grid_name>

Changer la mode d’isolement

Le mode d’isolement détermine comment SuperLink gère l’exécution du processus SuperExec. Cette configuration peut être ajustée à l’aide du paramètre superlink.isolationMode:

Exemple : Changement de mode d’isolement

superlink:
  isolationMode: process

# Don’t forget to enable the superexec if you don’t
# plan to use an existing one.
superexec:
  enabled: true

Déployez le Framework Flower avec TLS

Par défaut, le Framework Flower est déployé avec TLS activé. Cela signifie que tls.enabled est défini sur true.

Si cert-manager est installé dans votre cluster Kubernetes, ce chart peut être utilisé pour configurer TLS de plusieurs manières. Par défaut, il crée à la fois un Issuer auto-signé et un Certificate, mais vous pouvez également choisir de créer uniquement un Issuer ou de créer un Certificate à partir d’un Issuer/ClusterIssuer existant.

Quel que soit l’option que vous choisissez, TLS n’est activé qu’en définissant tls.enabled: true.

Comportement par défaut (Issuer auto-signé + Certificate)

global:
  domain: example.com

tls:
  enabled: true
  issuer:
    enabled: true
  certificate:
    enabled: true

Lorsque déployé avec ces valeurs, le chart crée un Issuer auto-signé et utilise ensuite celui-ci pour émettre un certificat TLS. Le Certificate généré est valable pendant cinq ans, est renouvelé quinze jours avant l’expiration et est stocké dans un secret Kubernetes.

Si vous laissez vide le champ secretName, le nom du secret par défaut est <chart-name>-server-tls. Le certificat inclut global.domain comme nom commun, ainsi que les entrées DNS de service et tout additionalHosts que vous fournissez.

Cette configuration convient mieux pour la mise en production et la validation des charts Helm dans un environnement non-produit.

Vous pouvez passer d’un certificat auto-signé à un autre type d’issuer en fournissant un bloc spec pour l”Issuer.

Créez un Certificate à l’aide d’un Issuer / ClusterIssuer existant

Utilisez cela si vous avez déjà un Issuer ou un ClusterIssuer (par exemple, Let’s Encrypt ou une CA corporative) et que vous souhaitez que le chart crée le Certificate.

global:
  domain: example.com

tls:
  enabled: true
  issuer:
    enabled: false
  certificate:
    enabled: true
    existingIssuer: letsencrypt-clusterissuer
    existingIssuerKind: ClusterIssuer

Avec cette configuration, le graphique ne crée pas un nouveau Issuer. Au lieu de cela, il référence l”Issuer Cluster nommé letsencrypt-clusterissuer spécifié et demande un Certificate à partir de celui-ci. Il est stocké dans un Secret Kubernetes qui, par défaut, porte le nom <chart-name>-server-tls.

Pour changer le nom du secret, définissez tls.certificate.secretName sur le nom souhaité :

tls:
  certificate:
    secretName: my-custom-tls-secret-name

Créez uniquement un Issuer

Dans ce mode, le graphique crée un Issuer mais ne crée pas de Certificate. C’est utile si vous voulez que cert-manager génère automatiquement des certificats en fonction des annotations Ingress.

tls:
  enabled: true
  issuer:
    enabled: true
  certificate:
    enabled: false
  existingSecret: ""

Voir la section Configuration Ingress pour plus d’informations.

Utilisez un Certificat TLS Existant

Si vous avez déjà un certificat TLS disponible sous forme de Secret Kubernetes, vous pouvez configurer le graphique pour l’utiliser directement au lieu de créer un nouveau Certificate avec cert-manager. Pour faire cela, désactivez la création de certificats et définissez tls.existingSecret sur le nom de votre Secret.

Le Secret doit être du type kubernetes.io/tls et contenir les champs standard tls.crt, tls.key, avec ca.crt étant facultatif. Si ca.crt n’est pas fourni, tls.crt sera également utilisé comme certificat CA.

Si à la fois tls.existingSecret et tls.certificate.enabled sont définis, la valeur de tls.existingSecret sera ignorée et un nouveau Certificate sera émis.

tls:
  enabled: true
  certificate:
    enabled: false
  existingSecret: my-custom-tls-secret

Remplacez les Chemins des Certificats

Par défaut, les drapeaux liés à TLS utilisent les chemins suivants lorsqu’il est activé :

--ssl-ca-certfile: /app/cert/ca.crt, --ssl-certfile: /app/cert/tls.crt, --ssl-keyfile: /app/cert/tls.key

Ces chemins peuvent être surchargés en spécifiant les drapeaux dans l” extraArgs, comme montré ci-dessous :

tls:
  enabled: true
superlink:
  enabled: true
  extraArgs:
    - --ssl-ca-certfile
    - /mount/cert/ca.cert
    - --ssl-certfile
    - /mount/cert/tls.cert
    - --ssl-keyfile
    - /mount/cert/tls.key

Déployer le Framework Flower sans TLS

Vous pourriez vouloir désactiver TLS pour la mise au point ou l’utilisation interne. Dans ce mode, le chart ne crée pas de ressources cert-manager Issuer ou Certificate, et toute configuration liée à TLS sur la ressource Ingress est ignorée.

tls:
  enabled: false

Configuration Ingress

Générer un Certificat via les annotations d’Ingress

Si vous préférez laisser cert-manager générer un Certificate par l’intermédiaire des annotations d’Ingress, vous pouvez désactiver la gestion de certificats intégrée du chart. Pour cela, définissez tls.certificate.enabled sur false et laissez tls.existingSecret vide. Assurez-vous également que tls.enabled est défini sur true.

Les annotations que vous spécifiez sous superlink.ingress.annotations seront transmises directement à la ressource Ingress. Pour les clés d’annotation prises en charge, consultez la documentation de cert-manager [(https://cert-manager.io/docs/usage/ingress/).

tls:
  enabled: true
  certificate:
    enabled: false
  existingSecret: ""

superlink:
 ingress:
    enabled: true
    annotations:
      nginx.ingress.kubernetes.io/backend-protocol: GRPCS
      nginx.ingress.kubernetes.io/force-ssl-redirect: "false"
      nginx.ingress.kubernetes.io/ssl-passthrough: "false"
      nginx.ingress.kubernetes.io/ssl-redirect: "false"
      cert-manager.io/cluster-issuer: cert-manager-selfsigned
      cert-manager.io/common-name: api.example.com
    api:
      enabled: true
      hostname: api.example.com
    tls:
      enabled: true

Le chart crée un Ingress pour SuperLink avec les annotations fournies. cert-manager génère un Certificate, et le stocke dans un Secret Kubernetes. Ce Secret est ensuite monté dans le conteneur SuperLink afin qu’il puisse utiliser la paire de clés TLS pour ses points d’entrée. Le même Secret est également référencé par la ressource Ingress, ce qui signifie que le certificat généré est partagé entre l” Ingress et le service SuperLink.

Par défaut, le certificat généré par Ingress est stocké dans un Secret nommé <chart-name>-server-tls.

Vous pouvez surcharger cela en définissant superlink.ingress.tls.secretName :

superlink:
 ingress:
    enabled: true
    tls:
      enabled: true
      secretName: my-custom-tls-secret

Important:

• Si tls.certificate.enabled est défini sur true ou si tls.existingSecret est spécifié, le secretName de la ressource Ingress est ignoré. Dans ce cas, le chart se référera à son propre mécanisme pour créer un certificat.

• Assurez-vous toujours que lorsque vous utilisez les annotations d’Ingress, aucun certificat n’est généré ou référencé par ce chart. Sinon, vous risquez de finir avec des secrets en conflit.

Certificat TLS avec hôtes supplémentaires

Par défaut, lorsqu’un certificat cert-manager est émis, il ne comprend que le nom DNS spécifié dans commonName, qui est dérivé de global.domain.

Dans certains déploiements, les charts serveur et client peuvent s’exécuter à l’intérieur du même cluster Kubernetes, tandis que l’API de contrôle est exposée publiquement sur Internet. Dans ce scénario, les SuperNodes doivent se connecter au SuperLink en utilisant son URL de service interne (par exemple, <superlink>.<namespace>.svc.cluster.local).

Pour supporter cela, vous pouvez étendre le certificat avec des hôtes supplémentaires en utilisant superlink.ingress.extraHosts.

L’exemple ci-dessous montre comment configurer l’Ingress pour que le certificat généré couvre à la fois le nom de domaine externe et le nom de service interne :

tls:
  enabled: true
  certificate:
    enabled: false
  existingSecret: ""

superlink:
 ingress:
    enabled: true
    annotations:
      nginx.ingress.kubernetes.io/backend-protocol: GRPCS
      nginx.ingress.kubernetes.io/force-ssl-redirect: "false"
      nginx.ingress.kubernetes.io/ssl-passthrough: "false"
      nginx.ingress.kubernetes.io/ssl-redirect: "false"
      cert-manager.io/cluster-issuer: cert-manager-selfsigned
      cert-manager.io/common-name: control.example.com
    control:
      enabled: true
      hostname: control.example.com
    extraHosts:
      - name: <superlink_name>.<namespace>.svc.cluster.local
        pathType: ImplementationSpecific
        path: /
        port: 9092
    tls:
      enabled: true

SSL-Passthrough

Dans certains scénarios, vous pouvez vouloir laisser le service SuperLink terminer TLS directement plutôt que d’avoir le contrôleur Ingress gérer la terminaison TLS. Cela est utile si vous avez besoin d’utiliser des protocoles tels que gRPC sur TLS end-to-end, où l’Ingress devrait simplement transmettre le trafic chiffré sans le déchiffrer.

Pour activer ce mode avec le contrôleur d’ingress NGINX, vous pouvez configurer la passe-partout SSL en définissant l’annotation nginx.ingress.kubernetes.io/ssl-passthrough sur « true ». Dans cette configuration, l’Ingress transmet directement le trafic TLS au conteneur SuperLink, qui traite ensuite la validation et l’encryption des certificats.

tls:
  enabled: true
  certificate:
    enabled: true

superlink:
  enabled: true
  ingress:
    annotations:
      nginx.ingress.kubernetes.io/backend-protocol: GRPCS
      nginx.ingress.kubernetes.io/force-ssl-redirect: "false"
      nginx.ingress.kubernetes.io/ssl-passthrough: "true"
      nginx.ingress.kubernetes.io/ssl-redirect: "false"
    ingressClassName: nginx
    tls: false
    control:
      enabled: true
      hostname: control.example.com
      path: /
      pathType: ImplementationSpecific
    fleet:
      enabled: true
      hostname: fleet.example.com
      path: /
      pathType: ImplementationSpecific
    serverAppIo:
      enabled: true
      hostname: serverappio.example.com
      path: /
      pathType: ImplementationSpecific

Activer l’authentification du nœud

global:
  nodeAuth:
    enabled: true
    authListPublicKeys:
      - ecdsa-sha2-nistp384 [...]
      - ecdsa-sha2-nistp384 [...]

tls:
  enabled: true

Les clés publiques peuvent inclure des commentaires à la fin des données de la clé :

global:
  nodeAuth:
    authListPublicKeys:
      - ecdsa-sha2-nistp384 [...] comment with spaces

Parameters

Paramètres Helm

Name	Description	Value
nameOverride	Remplacement des noms de l’application dans le fichier Chart.yaml	flower-server
fullnameOverride	Remplacement complet du nom généré.	""

Paramètres globaux

Name	Description	Value
global.annotations	Annotations par défaut	{}
global.labels	Étiquettes par défaut	{}
global.podLabels	PodLabels par défaut	{}
global.domain	Domaine par défaut	example.com
global.ingressClassName	IngressClass par défaut	""
global.nodeSelector	Sélecteur de nœud par défaut pour tous les composants	{}
global.tolerations	Tolérations par défaut pour tous les composants	[]
global.affinity.podAntiAffinity	Présentation d’affinité par défaut pour tous les composants	soft
global.affinity.podAntiAffinity	Règles d’anti-affinité du pod par défaut. Soit : rien, mou ou dur	soft
global.affinity.nodeAffinity.type	Règles d’affinité de nœud par défaut. Soit : rien, mou ou dur	hard
global.affinity.nodeAffinity.matchExpressions	Expressions de match pour l’affinité de nœud par défaut	[]
global.nodeAuth.enabled	Activer ou désactiver la liaison SuperLink <-> SuperNode	false
global.accountAuth.enabled	Activer ou désactiver le plugin d’authentification utilisateur.	false
global.accountAuth.config	Configurer l’authentification utilisateur.	{}
global.accountAuth.existingSecret	Secret existant avec configuration d’authentification utilisateur.	""
global.federationsConfig.enabled	Activer ou désactiver le plugin de configuration des fédérations.	false
global.federationsConfig.config	Configurer les fédérations.	{}
global.federationsConfig.existingSecret	Secret existant avec configuration des fédérations.	""
global.license.enabled	Activer ou désactiver la configuration du licence EE.	true
global.license.key	Clé de licence EE.	""
global.license.secretKey	Nom de la clé à l’intérieur du Secret Kubernetes	FLWR_LICENSE_KEY
global.license.existingSecret	Nom d’un Secret Kubernetes existant	""
global.securityContext.runAsUser	Définir le contexte de sécurité runAsUser	49999
global.securityContext.runAsGroup	Définir le contexte de sécurité runAsGroup	49999
global.securityContext.fsGroup	Définir le contexte de sécurité fsGroup	49999
global.podSecurityContext.runAsNonRoot	Définir le contexte de sécurité runAsNonRoot	true
global.podSecurityContext.readOnlyRootFilesystem	Définir le contexte de sécurité readOnlyRootFilesystem	true
global.podSecurityContext.allowPrivilegeEscalation	Définir le contexte de sécurité allowPrivilegeEscalation	false
global.podSecurityContext.seccompProfile.type	Définir le contexte de sécurité seccompProfile	RuntimeDefault
global.podSecurityContext.capabilities.drop	Définir le contexte de sécurité capabilities	["TOUT"]
global.env	Variables d’environnement par défaut	[]
global.image.pullPolicy	Politique de tirage d’image par défaut	IfNotPresent

Configuration TLS

Name	Description	Value
tls.enabled	Activer la configuration TLS pour le Framework Flower.	true
tls.issuer.enabled	Activer la création automatique d’un Issuer cert-manager.	true
tls.issuer.name	Nom du ressource Issuer à utiliser.	""
tls.issuer.spec	Contenu du bloc .spec pour l’Issuer cert-manager.	{}
tls.certificate.enabled	Activer la création automatique d’un Certificate cert-manager.	true
tls.certificate.annotations	Annotations CRD du Certificate.	{}
tls.certificate.secretName	Nom de la Secret Kubernetes pour stocker la clé et le certificat TLS.	""
tls.certificate.issuerGroup	Groupe API pour l’émetteur. Par défaut, cert-manager.io.	cert-manager.io
tls.certificate.existingIssuer	Nom d’un émetteur existant ou ClusterIssuer à utiliser.	""
tls.certificate.existingIssuerKind	Type de l’émetteur existant (Issuer ou ClusterIssuer).	""
tls.certificate.duration	Durée requise (c’est-à-dire la durée de vie) du Certificate.	43800h
tls.certificate.renewBefore	Durée avant l’expiration actuelle du certificat	360h
tls.certificate.privateKey	Options de clés privées. Il s’agit de l’algorithme de la clé et	{}
tls.certificate.usages	Utilisations requises de clés et utilisations étendues de clés.	[]
tls.certificate.additionalHosts	Hôtes supplémentaires que vous souhaitez ajouter dans le SAN’s	[]
tls.existingSecret	Nom d’un Secret Kubernetes existant	""

Composant SuperLink

Name	Description	Value
superlink.name	Nom du SuperLink	superlink
superlink.enabled	Activer ou désactiver SuperLink	true
superlink.resources	Définir les demandes et les limites des conteneurs pour différentes ressources comme la CPU ou la mémoire (essentiel pour les charges de travail de production)	{}
superlink.volumes	Spécifiez une liste de volumes pour le(s) pod(s) du SuperLink	[]
superlink.volumeMounts	Permet de spécifier des VolumeMounts supplémentaires	[]
superlink.isolationMode	Mode d’isolement du SuperLink	subprocess
superlink.automountServiceAccountToken	Automount SA-TOKEN dans le pod.	true
superlink.serviceAccount.enabled	Activer un compte de service pour le contrôleur d’application	true
superlink.serviceAccount.annotations	Annotations appliquées au compte de service activé	{}
superlink.serviceAccount.labels	Étiquettes appliquées au compte de service activé	{}
superlink.serviceAccount.automountServiceAccountToken	Automount SA-TOKEN	true
superlink.service.type	Sont valides ClusterIP, NodePort ou Loadbalancer	ClusterIP
superlink.service.servicePortControlName	Préfixe du port API de contrôle SuperLink	control
superlink.service.servicePortControl	Port à exposer pour l’API de contrôle SuperLink	9093
superlink.service.nodePortControl	Port node pour l’API de contrôle SuperLink	""
superlink.service.servicePortServerAppIoName	Préfixe du port API ServerAppIo SuperLink	serverappio
superlink.service.servicePortServerAppIo	Port à exposer pour l’API ServerAppIo SuperLink	9091
superlink.service.nodePortServerAppIo	Port node pour l’API ServerAppIo SuperLink	""
superlink.service.servicePortFleetName	Préfixe du port API Fleet SuperLink	fleet
superlink.service.servicePortFleet	Port à exposer pour l’API Fleet SuperLink	9092
superlink.service.nodePortFleet	Port du nœud pour l’API SuperLink Fleet	""
superlink.containerPorts.control	Port du conteneur pour l’API de contrôle SuperLink	9093
superlink.containerPorts.serverAppIo	Port du conteneur pour l’API ServerAppIo SuperLink	9091
superlink.containerPorts.fleet	Port du conteneur pour l’API SuperLink Fleet	9092
superlink.containerPorts.health	Port du conteneur pour l’API Health SuperLink	8081
superlink.replicaCount	Nombre de pods SuperLink à exécuter	1
superlink.labels	Étiquettes supplémentaires pour les pods SuperLink	{}
superlink.extraArgs	Ajouter des arguments supplémentaires aux arguments par défaut pour le SuperLink	[]
superlink.superexecAuthSecretFile	Chemin vers un fichier contenant le secret partagé SuperExec.	""
superlink.nodeSelector	Étiquettes du nœud pour les pods SuperLink qui se mélangent avec global.nodeSelector	{}
superlink.tolerations	Tolérations de nœud pour les pods SuperLink qui se mélangent avec global.tolerations	[]
superlink.updateStrategy.type	Type de stratégie de déploiement SuperLink	RollingUpdate
superlink.updateStrategy.rollingUpdate	Paramètres de configuration d’actualisation roulante SuperLink	{}
superlink.affinity	Affinité du nœud pour les pods SuperLink qui se mélangent avec global.affinity	{}
superlink.env	Tableau avec des variables d’environnement supplémentaires à ajouter aux nœuds SuperLink qui se mélangent avec global.env	[]
superlink.podSecurityContext	Paramètres de sécurité pour les pods SuperLink	{}
superlink.securityContext	Paramètres de sécurité pour le SuperLink	{}
superlink.livenessProbe.enabled	Activer livenessProbe sur les conteneurs SuperLink	true
superlink.livenessProbe.initialDelaySeconds	Délai initial en secondes pour livenessProbe	0
superlink.livenessProbe.periodSeconds	Période en secondes pour livenessProbe	10
superlink.livenessProbe.timeoutSeconds	Temps d’attente en secondes pour livenessProbe	1
superlink.livenessProbe.failureThreshold	Seuil de défaillance pour livenessProbe	3
superlink.livenessProbe.successThreshold	Seuil de réussite pour livenessProbe	1
superlink.readinessProbe.enabled	Activer readinessProbe sur les conteneurs SuperLink	true
superlink.readinessProbe.initialDelaySeconds	Délai initial en secondes pour readinessProbe	0
superlink.readinessProbe.periodSeconds	Période en secondes pour readinessProbe	10
superlink.readinessProbe.timeoutSeconds	Temps d’attente en secondes pour readinessProbe	1
superlink.readinessProbe.failureThreshold	Seuil de défaillance pour readinessProbe	3
superlink.readinessProbe.successThreshold	Seuil de réussite pour readinessProbe	1
superlink.ingress.enabled	Activer la ressource Ingress	false
superlink.ingress.annotations	Annotations supplémentaires pour l’Ingress	{}
superlink.ingress.ingressClassName	Définit quel contrôleur d’Ingress implémente la ressource	""
superlink.ingress.tls.enabled	Activer la terminaison TLS au niveau de l’Ingress.	false
superlink.ingress.tls.secretName	Nom du Secret Kubernetes qui contiendra le	""
superlink.ingress.control.enabled	Activer une ressource Ingress pour l’API SuperLink	false
superlink.ingress.control.hostname	Hôte Ingress pour l’ingress API SuperLink	control.example.com
superlink.ingress.control.path	Chemin d’accès de l’ingress API SuperLink	/
superlink.ingress.control.pathType	Type de chemin d’accès. L’un des Exact, Préfixe ou ImplementationSpecific	ImplementationSpecific
superlink.ingress.fleet.enabled	Activer une ressource Ingress pour l’API Fleet SuperLink	false
superlink.ingress.fleet.hostname	Hôte Ingress pour l’ingress API Fleet SuperLink	fleet.example.com
superlink.ingress.fleet.path	Chemin d’accès de l’ingress API Fleet SuperLink	/
superlink.ingress.fleet.pathType	Type de chemin d’accès. L’un des Exact, Préfixe ou ImplementationSpecific	ImplementationSpecific
superlink.ingress.serverAppIo.enabled	Activer une ressource Ingress pour l’API ServerAppIo SuperLink	false
superlink.ingress.serverAppIo.hostname	Hôte Ingress pour l’ingress API ServerAppIo SuperLink	serverappio.example.com
superlink.ingress.serverAppIo.path	Chemin d’accès de l’ingress API ServerAppIo SuperLink	/
superlink.ingress.serverAppIo.pathType	Type de chemin d’accès. L’un des Exact, Préfixe ou ImplementationSpecific	ImplementationSpecific
superlink.ingress.extraHosts	Tableau avec les hôtes supplémentaires à couvrir avec le registre d’Ingress	[]
superlink.ingress.extraTls	Configuration TLS pour les hôtes supplémentaires à couvrir avec ce registre d’Ingress	[]
superlink.ingress.extraRules	Règles supplémentaires à couvrir avec ce registre d’Ingress	[]
superlink.lifecycle	Conteneur(s) SuperLink à automatiser la configuration avant ou après le démarrage	{}
superlink.annotations	Annotations personnalisées supplémentaires pour SuperLink	{}
superlink.selectorLabels	Étiquettes de sélection supplémentaires pour les pods SuperLink	{}
superlink.podAnnotations	Annotations pour les pods SuperLink	{}
superlink.podLabels	Étiquettes de pod supplémentaires pour les pods SuperLink	{}
superlink.imagePullSecrets	Secrets d’image pull SuperLink qui dépassent les secrets globaux d’imagePullSecrets	[]
superlink.image.registry	Registre d’image SuperLink	registry.hub.docker.com
superlink.image.repository	Répertoire d’image SuperLink	flwr/superlink-ee
superlink.image.tag	Tag d’image SuperLink	1.29.0-ubuntu
superlink.image.digest	Digest d’image SuperLink	""
superlink.image.pullPolicy	Politique de pull d’image SuperLink qui dépassent la politique des composants image pullPolicy	IfNotPresent
superlink.networkPolicy.enabled	Spécifiez si une NetworkPolicy doit être créée	true
superlink.networkPolicy.allowExternal	Autoriser le trafic d’ingress externe	true
superlink.networkPolicy.allowExternalEgress	Autoriser un trafic egress non restreint	true
superlink.networkPolicy.extraIngress	Ajouter des règles d’ingress supplémentaires à la NetworkPolicy	[]
superlink.networkPolicy.extraEgress	Ajouter des règles d’ingress supplémentaires à la NetworkPolicy (ignorées si allowExternalEgress=true)	[]
superlink.networkPolicy.serverAppIo.ingressPodMatchLabels	Étiquettes pour correspondre et autoriser le trafic de pods provenant d’autres namespaces. Ignorées si superlink.networkPolicy.allowExternal est vrai.	{}
superlink.networkPolicy.serverAppIo.ingressNSMatchLabels	Étiquettes pour correspondre et autoriser le trafic de namespaces provenant d’autres namespaces. Ignorées si superlink.networkPolicy.allowExternal est vrai.	{}
superlink.networkPolicy.serverAppIo.ingressNSPodMatchLabels	Étiquettes de pod pour correspondre et autoriser le trafic de namespaces provenant d’autres namespaces. Ignorées si superlink.networkPolicy.allowExternal est vrai.	{}
superlink.networkPolicy.fleet.ingressPodMatchLabels	Étiquettes pour correspondre et autoriser le trafic de pods provenant d’autres namespaces. Ignorées si superlink.networkPolicy.allowExternal est vrai.	{}
superlink.networkPolicy.fleet.ingressNSMatchLabels	Étiquettes pour correspondre et autoriser le trafic de namespaces provenant d’autres namespaces. Ignorées si superlink.networkPolicy.allowExternal est vrai.	{}
superlink.networkPolicy.fleet.ingressNSPodMatchLabels	Étiquettes de pod pour correspondre et autoriser le trafic de namespaces provenant d’autres namespaces. Ignorées si superlink.networkPolicy.allowExternal est vrai.	{}
superlink.networkPolicy.control.ingressPodMatchLabels	Étiquettes pour correspondre et autoriser le trafic de pods provenant d’autres namespaces. Ignorées si superlink.networkPolicy.allowExternal est vrai.	{}
superlink.networkPolicy.control.ingressNSMatchLabels	Étiquettes pour correspondre et autoriser le trafic de namespaces provenant d’autres namespaces. Ignorées si superlink.networkPolicy.allowExternal est vrai.	{}
superlink.networkPolicy.control.ingressNSPodMatchLabels	Étiquettes de pod pour correspondre et autoriser le trafic de namespaces provenant d’autres namespaces. Ignorées si superlink.networkPolicy.allowExternal est vrai.	{}

Composant SuperExec

Name	Description	Value
superexec.name	Nom du SuperExec	superexec-serverapp
superexec.enabled	Activer ou désactiver SuperExec	false
superexec.pluginType	Type de plugin à utiliser.	serverapp
superexec.superlink	Adresse du SuperLink auquel le SuperExec doit se connecter	{}
superexec.superexecAuthSecretFile	Chemin vers un fichier contenant le secret partagé SuperExec.	""
superexec.allowRuntimeDependencyInstallation	Autoriser SuperExec à installer les dépendances runtime pour les applications Server.	false
superexec.resources	Définir les demandes et les limites des conteneurs pour différentes ressources comme la CPU ou la mémoire (essentiel pour les charges de travail de production)	{}
superexec.volumes	Spécifiez facultativement la liste des volumes pour les pods SuperExec	[]
superexec.volumeMounts	Permet de spécifier des VolumeMounts supplémentaires	[]
superexec.automountServiceAccountToken	Automount SA-TOKEN dans le pod.	true
superexec.serviceAccount.enabled	Activer un compte de service pour ce composant	true
superexec.serviceAccount.annotations	Annotations appliquées au compte de service activé	{}
superexec.serviceAccount.labels	Étiquettes appliquées au compte de service activé	{}
superexec.serviceAccount.automountServiceAccountToken	Automount SA-TOKEN	true
superexec.containerPorts.health	Port conteneur pour l’API de santé SuperExec	8081
superexec.podSecurityContext	Paramètres de sécurité pour les pods SuperExec	{}
superexec.livenessProbe.enabled	Activer livenessProbe sur les conteneurs SuperExec	true
superexec.livenessProbe.initialDelaySeconds	Délai initial en secondes pour livenessProbe	0
superexec.livenessProbe.periodSeconds	Période en secondes pour livenessProbe	10
superexec.livenessProbe.timeoutSeconds	Temps d’attente en secondes pour livenessProbe	1
superexec.livenessProbe.failureThreshold	Seuil de défaillance pour livenessProbe	3
superexec.livenessProbe.successThreshold	Seuil de réussite pour livenessProbe	1
superexec.readinessProbe.enabled	Activer readinessProbe sur les conteneurs SuperExec	true
superexec.readinessProbe.initialDelaySeconds	Délai initial en secondes pour readinessProbe	0
superexec.readinessProbe.periodSeconds	Période en secondes pour readinessProbe	10
superexec.readinessProbe.timeoutSeconds	Temps d’attente en secondes pour readinessProbe	1
superexec.readinessProbe.failureThreshold	Seuil de défaillance pour readinessProbe	3
superexec.readinessProbe.successThreshold	Seuil de réussite pour readinessProbe	1
superexec.replicas	Nombre de pods SuperExec à exécuter	1
superexec.labels	Étiquettes supplémentaires pour les pods SuperExec	{}
superexec.extraArgs	Ajouter des arguments supplémentaires aux arguments par défaut pour le SuperExec	[]
superexec.nodeSelector	Étiquettes de nœud pour les pods SuperExec qui se mélangent avec global.nodeSelector	{}
superexec.tolerations	Tolérations de nœud pour les pods SuperExec qui se mélangent avec global.tolerations	[]
superexec.updateStrategy.type	Type de stratégie de déploiement SuperExec	RollingUpdate
superexec.updateStrategy.rollingUpdate	Paramètres de configuration d’actualisation roulante pour le déploiement SuperExec	{}
superexec.affinity	Affinité de nœud pour les pods SuperExec qui se mélangent avec global.affinity	{}
superexec.env	Tableau avec des variables d’environnement supplémentaires à ajouter aux nœuds SuperExec qui se mélangent avec global.env	[]
superexec.lifecycle	Conteneurs SuperExec à automatiser la configuration avant ou après le démarrage	{}
superexec.annotations	Annotations personnalisées supplémentaires pour les pods SuperExec	{}
superexec.selectorLabels	Étiquettes de sélection supplémentaires pour les pods SuperExec	{}
superexec.podAnnotations	Annotations pour les pods SuperExec	{}
superexec.podLabels	Étiquettes de pod supplémentaires pour les pods SuperExec	{}
superexec.imagePullSecrets	Secrets d’image pull SuperExec qui surchargent global.imagePullSecrets	[]
superexec.image.registry	Registre d’image SuperExec	registry.hub.docker.com
superexec.image.repository	Répertoire d’image SuperExec	flwr/superexec-ee
superexec.image.tag	Tag d’image du SuperExec	1.29.0-ubuntu
superexec.image.digest	Digest d’image de SuperExec	""
superexec.image.pullPolicy	Politique de tirage d’image des composants	Always
superexec.networkPolicy.enabled	Spécifiez si une NetworkPolicy doit être créée	true
superexec.networkPolicy.allowExternalEgress	Autoriser un trafic egress non restreint	true
superexec.networkPolicy.extraEgress	Ajouter des règles d’ingress supplémentaires à la NetworkPolicy (ignorées si allowExternalEgress=true)	[]

Composant OpenFGA

Name	Description	Value
openfga.enabled	Activer le sous-chart openfga et déployer OpenFGA	false