Comparateur de toutes les paires clés-valeurs (allKeysValuesComparator)

Vérifie si toutes les combinaisons clé-valeur des éléments déployables supplémentaires sont identiques à celles de l'élément déployable principal.

Cas d'utilisation : détecter tout décalage de configuration entre les environnements de préparation et de production.

Arguments d'entrée

• additionalDeployablesInput
  • Liste d'éléments déployables supplémentaires à comparer avec l'élément déployable principal.
  • Type : liste
  • Obligatoire : vrai
• includeNodes
  • Valeur booléenne indiquant s'il faut inclure des nœuds autres que les éléments de données de configuration (CDI) pour la validation.
  • Valeur par défaut : faux
  • Type : vrai | faux
  • Obligatoire : faux
• exceptionList
  • Liste de noms de clés séparés par des virgules qui doivent être ignorés pendant la comparaison.
  • Type : chaîne
  • Obligatoire : faux

Domaines d'e-mail autorisés (authorizedEmailDomains)

Vérifie si une valeur de domaine d'un e-mail qui est identifiée sur la base d'une expression régulière est incluse dans la liste de domaines d'e-mail autorisés.

Entraîne un statut non conforme lorsqu'un domaine d'e-mail n'est pas un domaine autorisé.

Cas d'utilisation : empêcher les données (sensibles) de quitter un domaine de messagerie d'entreprise approuvé.

Arguments d'entrée

• authorizedDomains
  • Liste de domaines de messagerie autorisés séparés par des virgules.
  • Exemple :

    gmail.com,servicenow.com

  • Type : chaîne
  • Obligatoire : vrai
• exceptionList
  • Liste de noms de clés séparés par des virgules qui sont ignorés par la politique.
  • Type : chaîne
  • Obligatoire : faux

Hôtes autorisés dans les URL (authorisedHostsInURLS)

Vérifie si le format du composant hôte des valeurs d'URL dans un instantané est autorisé.

Entraîne un statut non conforme lorsque les valeurs d'URL d'un instantané ne sont pas conformes au format spécifié pour le composant hôte.

Cas d'utilisation : empêcher l'exposition de données (sensibles) par le biais d'URL non autorisées.

Arguments d'entrée

• authorizedHostsRegex
  • Liste d'expressions régulières séparées par des virgules et utilisées pour valider le composant hôte dans les URL.
  • Exemple :

    notpresent$,code.devsnc+,mydomain.com

  • Type : chaîne
  • Obligatoire : vrai
• exceptionList
  • Liste de noms de clés séparés par des virgules qui sont ignorés par la politique.
  • Type : chaîne
  • Obligatoire : faux

Combinaisons clé-valeur autorisées (authorisedKVCombinations)

Vérifie si les valeurs de clés d'entrée trouvées dans un instantané sont autorisées.

Entraîne un statut de non-conformité lorsqu'une clé a une valeur non autorisée.

Arguments d'entrée

• authorisedList
  • Liste JSON des clés avec une liste de valeurs de chaîne autorisées pour chaque clé.
  • Exemple :

    {
      "image":"k8s.example.io,gke.example.io,docker.example.com:8444", 
      "domain":"example.service-now.com"
    }

  • Type : JSON
  • Obligatoire : vrai
• caseSensitive
  • Valeur booléenne pour indiquer si les clés autorisées et leurs valeurs de clés utilisées pour la validation sont sensibles à la casse.
  • Valeur par défaut : faux
  • Type : vrai | faux
  • Obligatoire : faux

Plage de ports autorisés (authorisedPortsRange)

Vérifie si les valeurs de port d'entrée trouvées dans un instantané sont autorisées.

Entraîne un statut de non-conformité lorsqu'une valeur de port n'est pas dans la plage acceptable.

Validateur de certificat (certificateValidator)

Vérifie si les certificats existent dans un instantané et s'ils ont expiré ou vont expirer pendant la période d'expiration.

Entraîne un statut non conforme lorsque la clé date d'expiration ou la clé certificat avec la valeur de format codée PEM dans un instantané a expiré ou expirera pendant la période d'expiration. La période d'expiration est calculée à partir de la date d'exécution de la politique à laquelle sont ajoutés les jours d'expiration.

Arguments d'entrée

• certificatesNode
  • Nom du nœud qui contient les certificats.
  • Valeur par défaut : certificats
  • Type : chaîne
  • Obligatoire : vrai
• expirationDays
  • Nombre de jours pour calculer la période d'expiration des certificats. La période d'expiration est calculée à partir de la date d'exécution de la politique à laquelle sont ajoutés les jours d'expiration.
  • Type : entier
  • Obligatoire : faux
• exceptionList
  • Liste de noms de certificat séparés par des virgules qui sont ignorés par la politique.
  • Type : chaîne
  • Obligatoire : faux

Comparateur de nœuds cohérents (consistentNodesComparator)

Vérifie si toutes les combinaisons clé-valeur sont identiques pour chaque nœud de premier niveau d'un instantané.

Entraîne un statut de non-conformité lorsque deux nœuds de premier niveau dans un instantané ont des combinaisons clé-valeur différentes.

Cas d'utilisation : lorsque tous les nœuds d'un instantané sont un groupe d'appareils ou de machines virtuelles (MV), ils ont la même configuration.

Argument d'entrée

exceptionList

• Liste de nœuds ou de combinaisons clé-valeur séparés par des virgules à exclure de la validation.
• Type : chaîne
• Obligatoire : faux

Regex d'hôte correct (correctHostRegex)

Vérifie le format des clés liées à l'hôte pour s'assurer qu'un nom d'hôte peut être utilisé.

Entraîne un statut de non-conformité lorsqu'une clé avec une valeur d'URL dans un instantané ne correspond pas à l'expression régulière fournie pour les hôtes autorisés.

Arguments d'entrée

• authorizedHostRegex
  • Expression régulière utilisée pour valider le composant hôte dans les URL.
  • Exemple :

    mydomain.com

  • Type : chaîne
  • Obligatoire : vrai
• exceptionList
  • Liste de clés séparées par des virgules avec les valeurs d'URL à exclure de la comparaison.
  • Type : chaîne
  • Obligatoire : faux

Détecter les variables inutilisées (detectUnusedVariables)

Vérifie si le dossier vars d'un élément déployable ou d'une collection inclut des variables qui ne sont pas utilisées dans un instantané.

Entraîne un avertissement lorsqu'une variable est déclarée, mais pas utilisée dans un instantané.

Noms de clés différents Mêmes valeurs (differentKeyNamesSameValues)

Vérifie si les valeurs sont identiques pour les paires de clés.

Entraîne un statut non conforme lorsque les paires de clés spécifiées n'ont pas la même valeur.

Cas d'utilisation : obtenir un contrôle plus précis des conditions en vérifiant que les valeurs sont les mêmes pour différentes clés.

Argument d'entrée

keyPairs

• Tableau de paires de clés qui doivent avoir les mêmes valeurs. Une paire de clés doit avoir des clés différentes et ne doit pas se composer d'une seule clé ([key1) ou de plusieurs clés ([key1=key2=key3]).
• Exemple :

  ["key1=key3","key2=key4"]

• Type : tableau de chaînes
• Obligatoire : vrai

Comparateur de nœuds de valeurs différentes (differentValuesNodesComparator)

Vérifie si la valeur de clé est différente dans tous les composants lorsqu'une clé existe dans plusieurs composants d'un instantané.

Argument d'entrée

keynameList

• Liste de noms de clés séparés par des virgules qui doivent avoir des valeurs différentes pour les nœuds de premier niveau.
• Exemple :

  key1,key2

• Type : chaîne
• Obligatoire : vrai

Validateur de format d'image Docker (dockerImageFormatValidator)

Vérifie si l'image Docker d'un service suit la regex comme spécifié dans l'entrée. Par exemple, fournissez une valeur regex pour garantir que le balisage et la gestion des versions des images Docker suivent les bonnes pratiques.

Entraîne un statut non conforme lorsque la valeur d'image ne correspond pas à la valeur d'entrée regex dans l'argument d'entrée imageExpectedRegex.

Arguments d'entrée

• imageExpectedRegex
  • Valeur regex pour une image Docker.
    Exemple de valeur d'entrée pour garantir que la balise d'une image est une valeur alphanumérique :

     ^.*:([0-9]+.?)+([-_]{1}[A-Za-z0-9.]+)?$

  • Type : chaîne
  • Obligatoire : vrai
• serviceExceptionList
  • Liste de services séparés par des virgules qui sont exemptés de la validation.
  • Type : chaîne
  • Obligatoire : faux

Validateur du registre d'images Docker (dockerImageRegistryValidator)

Vérifie si le registre d'une image Docker est inclus dans la liste autorisée de registres.

Analyse l'image Docker pour chaque service, extrait la valeur d'un registre dans une image, puis vérifie si la valeur de registre extraite est incluse dans l'entrée authorizedRegistryList.

Entraîne un statut non conforme lorsque le registre d'images n'est pas dans l'entrée authorizedRegistryList.

Argument d'entrée

authorizedRegistryList

• Liste de registres séparés par des virgules.
  Exemple :

  k8s.example.io,gke.example.io,docker.example.com:8444

• Type : chaîne
• Obligatoire : vrai

Validateur de réseau Docker (dockerNetworkValidator)

Vérifie si le réseau d'un service Docker est défini dans les sections du réseau.

Entraîne un statut non conforme lorsque le réseau d'un service n'est pas défini dans la section de réseau de niveau supérieur ou lorsque le réseau d'un service configuré dans la propriété labels/com.docker.lb.network n'est pas défini dans la section de niveau de service et la section de réseau de niveau supérieur.

Valeurs en double (duplicateValues)

Vérifie les valeurs en double dans un instantané.

Entraîne un statut non conforme lorsqu'il existe des valeurs de clé en double dans un instantané, à l'exception des valeurs définies dans la liste d'exception.

Cas d'utilisation : obtenir un contrôle plus précis des conditions en vérifiant que les valeurs des instantanés sont différentes.

Arguments d'entrée

• includePath
  • Valeur booléenne indiquant s'il faut inclure le chemin d'accès complet du nœud dans la sortie.
  • Valeur par défaut : vrai
  • Type : vrai | faux
  • Obligatoire : vrai
• pathSeparator
  • Chaîne indiquant le séparateur de chemin pour les nœuds.
  • Valeur par défaut : /
  • Type : chaîne
  • Obligatoire : vrai
• exceptionList
  • Tableau de chaînes à exclure de la validation.
  • Valeur par défaut : [ « vrai », « faux », « oui », « non », « activé », « désactivé »]
  • Type : tableau de chaînes
  • Obligatoire : faux

Combinaisons clé-valeur interdites (forbiddenKVcombinations)

Vérifie s'il existe des combinaisons clé-valeur interdites dans un instantané.

Entraîne un statut de non-conformité lorsqu'une clé trouvée dans un instantané a une valeur interdite comme spécifié dans la liste d'entrée.

Argument d'entrée

forbiddenKV

• Liste JSON de clés avec une liste de valeurs interdites pour chaque clé.
• Exemple :

  {
    "username":"root,admin",
     "password":"qwerty123"
  }

• Type : JSON
• Obligatoire : vrai

Validateur de liste générique (genericListValidator)

Compare les valeurs de clés d'un instantané avec la liste des valeurs fournies dans l'entrée. La valeur de clé peut être une chaîne, une liste de chaînes séparées par des virgules, un tableau de chaînes ou un objet. Lorsque la valeur de clé est un objet, les clés de l'objet sont utilisées dans la comparaison.

Notez les points suivants concernant la conformité à la politique :

• Lorsque l'opérateur est IN, la politique est conforme lorsque toutes les chaînes de la valeur de clé sont incluses dans la liste d'entrée.
• Lorsque l'opérateur est EQUALS, la politique est conforme lorsque toutes les chaînes de la valeur de clé correspondent à toutes les chaînes, répertoriées dans n'importe quel ordre, dans la liste d'entrée.
• Lorsque l'opérateur est CONTAINS, la politique est conforme lorsque la valeur de clé contient toutes les chaînes de la liste d'entrée.
• Lorsque l'opérateur est NOT CONTAINS, la politique est conforme lorsqu'aucune des chaînes de la valeur de clé n'existe dans la liste d'entrée.

Arguments d'entrée

• keysToValidateObject
  • Tableau d'objets où chaque objet contient un chemin d'accès de clé, un opérateur et une liste de référence.
  • Les opérateurs autorisés sont IN, CONTAINS, NOT CONTAINS et EQUALS.
  • Exemple de valeur d'entrée pour imposer qu'un utilisateur défini dans le chemin d'accès système/racine/utilisateur soit user1 ou user2 :

    [ 
        { 
          keyPath: ["system", “root”, "user"]  
    
          operator: "IN" 
    
          referenceList: [user1, user2] 
    
         } 
    ]

  • Valeur par défaut : []
  • Type : tableau d'objets
  • Obligatoire : vrai
• caseSensitive
  • Valeur booléenne pour indiquer si la comparaison de liste doit être sensible à la casse.
  • Valeur par défaut : vrai
  • Type : vrai | faux
  • Obligatoire : faux

Validateur générique (genericValidator)

Vérifie si la valeur d'une clé est valide en fonction de l'opérateur et de la valeur d'entrée de référence.

Notez les points suivants concernant la conformité à la politique :

• Lorsque l'opérateur est = ou ==, la politique est conforme lorsque la valeur de clé correspond à la valeur d'entrée de référence.
• Lorsque l'opérateur est <, la politique est conforme lorsque la valeur de clé est inférieure à la valeur d'entrée de référence.
• Lorsque l'opérateur est >, la politique est conforme lorsque la valeur de clé est supérieure à la valeur d'entrée de référence.
• Lorsque l'opérateur est <=, la politique est conforme lorsque la valeur de clé est inférieure ou égale à la valeur d'entrée de référence.
• Lorsque l'opérateur est >=, la politique est conforme lorsque la valeur de clé est supérieure ou égale à la valeur d'entrée de référence.
• Lorsque l'opérateur est != ou <>, la politique est conforme lorsque la valeur de clé ne correspond pas à la valeur d'entrée de référence.
• Lorsque l'opérateur est IN, la politique est conforme lorsque la valeur de clé est incluse dans la liste d'entrée de référence.
• Lorsque l'opérateur est NOT IN, la politique est conforme lorsque la valeur de clé n'est pas incluse dans la liste d'entrée de référence.
• Lorsque l'opérateur est CONTAINS, la politique est conforme lorsque la valeur de clé contient la valeur d'entrée de référence.
• Lorsque l'opérateur est NOT CONTAINS, la politique est conforme lorsque la valeur de clé ne contient pas la valeur d'entrée de référence.
• Lorsque l'opérateur est REGEX, la politique est conforme lorsque la valeur de clé correspond au schéma d'expression régulière spécifié dans la valeur d'entrée de référence.

Arguments d'entrée

• keysToValidate
  • Tableau d'objets où chaque objet contient une clé, un opérateur et une valeur de référence.
  • Les opérateurs autorisés sont <, <=, >, >=, = ou ==, <> ou !=, RANGE, CONTAINS, NOT CONTAINS, IN, NOT IN et REGEX.
  • Exemple :

    [
          {
            "key": "webport-KO",
            "operator": "RANGE",
            "refValue": "8000-9000"
          },
          {
            "key": "webport-OK",
            "operator": ">=",
            "refValue": 8000
          },
          {
            "key": "fqdn-OK",
            "operator": "REGEX",
            "refValue": ".francecentral.cloudapp.azure.com$"
          },
          {
            "key": "trace_level-KO",
            "operator": "IN",
            "refValue": "INFO,ERROR,FATAL"
          },
          {
            "key": "trace_level-KO",
            "operator": "NOT IN",
            "refValue": "DEBUG,VERBOSE"
          },
          {
            "key": "trace-KO-ifcasesensitive",
            "operator": "CONTAINS",
            "refValue": "ERROR"
          }
        ]

  • Type : chaîne
  • Obligatoire : vrai
• caseSensitive
  • Valeur booléenne pour indiquer si la comparaison de liste doit être sensible à la casse.
  • Valeur par défaut : vrai
  • Type : vrai | faux
  • Obligatoire : faux

Comparateur d'existence de clé (keyExistenceComparator)

Vérifie si toutes les clés d'un élément déployable principal existent également dans les éléments déployables supplémentaires fournis dans l'entrée.

Entraîne un statut non conforme si une clé est présente dans l'élément déployable principal, mais pas dans les éléments déployables supplémentaires.

Cas d'utilisation : comparer vos variables d'environnement et vérifier qu'elles sont cohérentes.

Arguments d'entrée

• additionalDeployablesInput
  • Liste d'éléments déployables supplémentaires à comparer avec l'élément déployable principal.
  • Type : liste
  • Obligatoire : vrai
• includeNodes
  • Valeur booléenne indiquant s'il faut inclure les nœuds enfants des éléments déployables pendant la comparaison.
  • Valeur par défaut : faux
  • Type : vrai | faux
  • Obligatoire : faux
• caseSensitive
  • Valeur booléenne pour indiquer si la comparaison de clé est sensible à la casse.
  • Valeur par défaut : faux
  • Type : vrai | faux
  • Obligatoire : faux
• exceptionList
  • Liste de noms de clés séparés par des virgules qui doivent être ignorés pendant la comparaison.
  • Type : chaîne
  • Obligatoire : faux

Convention de dénomination de clé (keyNamingConvention)

Vérifie si les noms de clés suivent un schéma de dénomination donné.

Entraîne un statut de non-conformité lorsque les clés ne suivent pas le schéma de dénomination préfixe-suffixe comme spécifié dans les arguments d'entrée.

Arguments d'entrée

• maxLength
  • Valeur entière indiquant la longueur maximale d'un nom de clé.
  • Type : entier
  • Obligatoire : faux
• approvedPrefixArray
  • Tableau de chaînes qui indiquent les préfixes approuvés pour un nom de clé.
  • Type : tableau de chaînes
  • Obligatoire : faux
• includePath
  • Valeur booléenne indiquant s'il faut inclure le chemin d'accès complet du nœud dans la sortie.
  • Valeur par défaut : vrai
  • Type : vrai | faux
  • Obligatoire : vrai
• approvedSuffixArray
  • Tableau de chaînes qui indiquent les suffixes approuvés pour un nom de clé.
  • Type : tableau de chaînes
  • Obligatoire : faux
• exceptionList
  • Liste de clés séparées par des virgules à exclure de la validation.
  • Type : chaîne
  • Obligatoire : faux

Validateur du chemin d'accès de la clé (keyPathValidator)

Vérifie si une clé pour le chemin d'accès à la clé spécifié est trouvée dans un instantané et, si elle est trouvée, la valeur de la clé est valide en fonction de la valeur de l'opérateur et de la valeur d'entrée de référence.

Entraîne un statut de non-conformité lorsque la clé du chemin d'accès de clé spécifié a une valeur non valide. En outre, si l'argument d'entrée ignoreIfNotFound est défini sur faux, cela entraîne un statut de non-conformité lorsque le chemin d'accès à la clé spécifié dans l'argument d'entrée n'est pas trouvé dans un instantané.

Arguments d'entrée

• pathAndDesiredValues
  • Objet JSON qui contient un ensemble de clés et un mappage de condition et de valeur que les clés doivent avoir.
  • Exemple :

    {
        "release-1.0/paymentService-V1.0/integerValues": ["<","3"],
        "release-1.0/paymentService-V1.0/database/dbPort": [">","8000"]
    }

  • Type : JSON
  • Obligatoire : vrai
• pathSeparator
  • Chaîne indiquant le séparateur de chemin pour les nœuds.
  • Valeur par défaut : /
  • Type : chaîne
  • Obligatoire : vrai
• ignoreIfNotFound
  • Valeur booléenne indiquant si la clé du chemin d'accès de la clé spécifié doit exister dans un instantané.
  • Valeur par défaut : vrai
  • Type : vrai | faux
  • Obligatoire : faux

Vérification de sous-chaîne de valeur de clé (keyValueSubstringCheck)

Recherche la sous-chaîne spécifiée dans la valeur d'un instantané pour un nom de clé spécifié.

Entraîne un statut de non-conformité lorsque la valeur d'un nom de clé ne contient pas la sous-chaîne spécifiée dans l'argument d'entrée.

Argument d'entrée

keyNameWithKeyValues

• Objet JSON qui contient un ensemble de sous-chaînes obligatoire, incluant des paires de sous-chaînes de nom de clé, de sous-chaîne et de sous-chaînes de valeur de clé.
• Exemple :

  {
    "live": "2022"
    "environment": "aws"
  }

• Type : JSON
• Obligatoire : vrai

Comparateur de liste (listComparator)

Vérifie si deux clés ont les mêmes valeurs en comparant la liste de valeurs entre les deux clés. La comparaison n'est pas sensible à la casse.

Entraîne un statut non conforme lorsque toutes les listes de valeurs de la première clé correspondent à toutes les valeurs, répertoriées dans n'importe quel ordre, de la deuxième clé.

Arguments d'entrée

• list1Node
  • Nom de clé du nœud primaire.
  • Type : chaîne
  • Obligatoire : vrai
• list2Node
  • Nom de clé du nœud à comparer avec le nœud primaire.
  • Type : chaîne
  • Obligatoire : vrai

Clés obligatoires (mandatoryKeys)

Vérifie si la liste des noms de clés spécifiés dans l'entrée est présente dans un instantané.

Entraîne un statut non conforme lorsque le nom de clé spécifié n'est pas présent dans un instantané.

Arguments d'entrée

• mandatoryKeys
  • Liste de noms de clés séparés par des virgules.
  • Type : chaîne
  • Obligatoire : vrai
• caseSensitive
  • Valeur booléenne pour indiquer si la comparaison de clé est sensible à la casse.
  • Valeur par défaut : faux
  • Type : vrai | faux
  • Obligatoire : faux

Validateur de limite de mémoire (memoryLimitValidator)

Vérifie si les ressources affectées à une valeur de clé se trouvent dans les limites spécifiées d'une unité de mémoire. Compare des valeurs de clés non sensibles à la casse des unités de mesure (y compris Ko, Mo et Go) et des unités binaires (y compris Kio, Mio et Gio). Convertit une valeur de clé et ses valeurs d'entrée en octets avant la comparaison.

Entraîne un statut non conforme lorsqu'une valeur de clé ne se trouve pas dans les limites spécifiées ou n'est pas une unité de mémoire.

Argument d'entrée

pathAndLimitsArray

• Tableau des chemins d'accès aux clés et des valeurs minimales et maximales des limites d'unités de mémoire telles que min. et max.
• Type : tableau d'objets
• Obligatoire : vrai

Exemple :

[ 
    { 
    keyPath: ["deploy", "resources", "limits", "cpu"], 
    min: "250m", 
    max: "500m" 
    }, 
    { 
    keyPath: ["deploy", "resources", "limits", "cpu"], 
    min: "1GB", 
    max: "8GB" 
    } 
]

Liste de balises obligatoires (mandatoryTagsList)

Vérifie si les valeurs des nœuds de balise trouvés dans un instantané sont autorisées.

Valeur obligatoire (mandatoryValue)

Vérifie si toutes les clés fournies en tant qu'entrée ont une valeur non vide.

Entraîne un statut non conforme lorsque la valeur d'une clé est nulle ou vide, ou un avertissement lorsque le nom de clé spécifié dans l'entrée est introuvable dans un instantané.

Arguments d'entrée

• keysList

  • Liste de noms de clés séparés par des virgules.
  • Type : chaîne
  • Obligatoire : vrai
• stopAtFirstFound
  • Valeur booléenne indiquant s'il faut vérifier uniquement la première occurrence de la valeur de clé dans un instantané.
  • Valeur par défaut : vrai
  • Type : vrai | faux
  • Obligatoire : vrai
• trimValue
  • Valeur booléenne indiquant s'il faut supprimer les espaces de début ou de fin de la valeur de clé avant la comparaison.
  • Valeur par défaut : vrai
  • Type : vrai | faux
  • Obligatoire : vrai
• caseSensitive
  • Valeur booléenne pour indiquer si la comparaison de clé est sensible à la casse.
  • Valeur par défaut : faux
  • Type : vrai | faux
  • Obligatoire : faux

Valeur obligatoire par type (mandatoryValueByType)

Vérifie si toutes les clés fournies en tant qu'entrée ont une valeur non vide.

Arguments d'entrée

• keyNamesString
  • Liste de noms de clés séparés par des virgules qui doivent avoir une valeur de chaîne.
  • Type : chaîne
  • Obligatoire : faux
• keyNamesInteger
  • Liste de noms de clés séparés par des virgules qui doivent avoir une valeur entière.
  • Type : chaîne
  • Obligatoire : faux
• keyNamesBoolean
  • Liste de noms de clés séparés par des virgules qui doivent avoir une valeur booléenne.
  • Type : chaîne
  • Obligatoire : faux

Aucune donnée sensible en clair (noClearSensitiveData)

Vérifie si les valeurs sont chiffrées pour les noms de clés contenant les mots clés spécifiés.

Entraîne un statut non conforme lorsque le nom de la clé contenant les mots clés spécifiés n'est pas chiffré.

Cas d'utilisation : DevOps Config est utilisé par les organisations pour gérer et gouverner les données sensibles (mots de passe, clés API et jetons) grâce à ses contrôles d'accès basés sur les autorisations.

Arguments d'entrée

• keyWords
  • Liste de chaînes séparées par des virgules utilisées pour identifier les clés sensibles dans un instantané. La politique utilise la méthode de comparaison non sensible à la casse.
  • Valeur par défaut : pass,pwd,secret
  • Type : chaîne
  • Obligatoire : vrai
• exceptionList
  • Liste de clés séparées par des virgules à exclure de la validation.
  • Type : chaîne
  • Obligatoire : faux

Aucune clé en double (noDuplicateKeys)

Vérifie s'il n'y a pas de noms de clés en double dans un instantané.

Entraîne un statut non conforme si un nom de clé comporte plusieurs occurrences dans un instantané.

Cas d'utilisation : les outils d'automatisation du déploiement peuvent mal gérer plusieurs occurrences de paramètres, ce qui entraîne des temps d'arrêt des services.

Argument d'entrée

keyNames

• Liste de noms de clés séparés par des virgules.
• Valeur par défaut : dbConnectionString,dbUserName
• Type : chaîne
• Obligatoire : faux

Aucune valeur vide (noEmptyValues)

Vérifie si toutes les clés ont une valeur non vide.

Entraîne un statut non conforme lorsque la valeur d'une clé non incluse dans la liste d'exceptions est nulle ou vide.

Arguments d'entrée

• trimValue
  • Valeur booléenne indiquant s'il faut supprimer les espaces de début ou de fin de la valeur de clé avant la comparaison.
  • Valeur par défaut : vrai
  • Type : vrai | faux
  • Obligatoire : vrai
• caseSensitive
  • Valeur booléenne pour indiquer si la comparaison de clé est sensible à la casse.
  • Valeur par défaut : faux
  • Type : vrai | faux
  • Obligatoire : faux
• exceptionList
  • Liste de clés séparées par des virgules à exclure de la validation.
  • Type : chaîne
  • Obligatoire : faux

Aucune valeur interdite (noForbiddenValues)

Vérifie s'il existe des noms de clés avec des valeurs interdites dans un instantané.

Entraîne un statut de non-conformité lorsqu'une clé trouvée dans un instantané a une valeur interdite comme spécifié dans la liste d'entrée.

Arguments d'entrée

• forbiddenValues
  • Liste de valeurs interdites séparées par des virgules.
  • Valeur par défaut : racine
  • Type : chaîne
  • Obligatoire : faux
• excludedKeyNames
  • Liste de clés séparées par des virgules à exclure de la validation.
  • Valeur par défaut : name,*desc*
  • Type : chaîne
  • Obligatoire : faux

Pas de FTP (noFTP)

Vérifie si toutes les URL d'un instantané utilisent le protocole FTPS.

Entraîne un statut non conforme lorsqu'une URL contient FTP dans un instantané.

Arguments d'entrée

• searchValue
  • Terme de recherche qui ne doit pas figurer dans la valeur de clé.
  • Valeur par défaut : FTTP:/
  • Type : chaîne
  • Obligatoire : vrai
• caseSensitive
  • Valeur booléenne pour indiquer si la comparaison de clé est sensible à la casse.
  • Valeur par défaut : faux
  • Type : vrai | faux
  • Obligatoire : faux
• exceptionList
  • Liste de clés séparées par des virgules à exclure de la validation.
  • Type : chaîne
  • Obligatoire : faux

Pas de HTTP (noHTTP)

Vérifie si toutes les URL d'un instantané utilisent le protocole HTTPS.

Entraîne un statut non conforme lorsqu'une URL contient HTTP dans un instantané.

Arguments d'entrée

• searchValue
  • Terme de recherche qui ne doit pas figurer dans la valeur de clé.
  • Valeur par défaut : HTTP:/
  • Type : chaîne
  • Obligatoire : vrai
• caseSensitive
  • Valeur booléenne pour indiquer si la comparaison de clé est sensible à la casse.
  • Valeur par défaut : faux
  • Type : vrai | faux
  • Obligatoire : faux
• exceptionList
  • Liste de clés séparées par des virgules à exclure de la validation.
  • Type : chaîne
  • Obligatoire : faux

Comparateur de clés de nœud (nodeKeysComparator)

Vérifie si toutes les clés du nœud primaire sont identiques dans le nœud secondaire.

Entraîne un statut non conforme si une clé est présente dans le nœud primaire, mais pas dans le nœud secondaire ou inversement.

Arguments d'entrée

• fromNode
  • Tableau de chaînes indiquant le chemin d'accès du nœud primaire dans un instantané.
  • Valeur par défaut : []
  • Type : tableau de chaînes
  • Obligatoire : vrai
• toNode
  • Tableau de chaînes indiquant le chemin d'accès au nœud secondaire dans un instantané.
  • Valeur par défaut : []
  • Type : tableau de chaînes
  • Obligatoire : vrai
• includePath
  • Valeur booléenne indiquant s'il faut inclure le chemin d'accès complet du nœud dans la sortie.
  • Valeur par défaut : vrai
  • Type : vrai | faux
  • Obligatoire : faux

Pas de LDAP (noLDAP)

Vérifie si toutes les URL d'un instantané utilisent le protocole LDAPS.

Entraîne un statut non conforme lorsqu'une URL contient LDAP dans un instantané.

Arguments d'entrée

• searchValue
  • Terme de recherche qui ne doit pas figurer dans la valeur de clé.
  • Valeur par défaut : LDAP:/
  • Type : chaîne
  • Obligatoire : vrai
• caseSensitive
  • Valeur booléenne pour indiquer si la comparaison de clé est sensible à la casse.
  • Valeur par défaut : faux
  • Type : vrai | faux
  • Obligatoire : faux
• exceptionList
  • Liste de clés séparées par des virgules à exclure de la validation.
  • Type : chaîne
  • Obligatoire : faux

Comparateur de valeurs de nœuds (nodesValueComparator)

Compare toutes les combinaisons clé-valeur entre deux nœuds dans un instantané.

Cas d'utilisation : assurer la cohérence entre les nœuds en comparant les valeurs des clés entre deux nœuds.

Arguments d'entrée

• fromNode
  • Tableau de chaînes indiquant le chemin d'accès du nœud primaire dans un instantané.
  • Valeur par défaut : []
  • Type : tableau de chaînes
  • Obligatoire : vrai
• toNode
  • Tableau de chaînes indiquant le chemin d'accès au nœud secondaire dans un instantané.
  • Valeur par défaut : []
  • Type : tableau de chaînes
  • Obligatoire : vrai
• includePath
  • Valeur booléenne indiquant s'il faut inclure le chemin d'accès complet du nœud dans la sortie.
  • Valeur par défaut : vrai
  • Type : vrai | faux
  • Obligatoire : faux
• sameValueKeys
  • Liste de noms de clés séparés par des virgules avec les mêmes valeurs.
  • Type : chaîne
  • Obligatoire : faux
• diffValueKeys
  • Liste de noms de clés séparés par des virgules avec des valeurs différentes.
  • Type : chaîne
  • Obligatoire : faux
• allowMissingKeys
  • Valeur booléenne indiquant s'il faut vérifier que toutes les clés du nœud primaire sont identiques dans le nœud secondaire.
  • Valeur par défaut : faux
  • Type : vrai | faux
  • Obligatoire : faux

Aucun caractère d'espace autorisé (noWhiteSpaceAllowed)

Vérifie que les valeurs de clés ne contiennent aucun espace, y compris des espaces de début et de fin.

Entraîne un statut non conforme lorsqu'une valeur de clé inclut un caractère espace.

Valeur de clé identique (sameKeyValue)

Vérifie que les valeurs d'une clé incluse dans plusieurs composants d'un instantané sont identiques dans tous les composants.

Entraîne un statut non conforme lorsqu'une clé a des valeurs différentes dans plusieurs composants.

Argument d'entrée

keyList

• Liste de noms de clés séparés par des virgules
• Obligatoire : vrai
• Type : chaîne

Comparateur de valeurs identiques (sameValuesComparator)

Vérifie si toutes les clés fournies en tant qu'argument d'entrée keyList ont la même valeur dans les éléments déployables.

Entraîne un statut non conforme lorsque la valeur d'une clé est différente dans plusieurs éléments déployables ou entraîne un avertissement lorsque le nom de clé spécifié dans l'entrée n'est trouvé dans aucun des éléments déployables.

Cas d'utilisation : détecter tout décalage de configuration entre les environnements de préparation et de production.

Arguments d'entrée

• additionalDeployablesInput
  • Liste d'éléments déployables supplémentaires à comparer avec l'élément déployable principal.
  • Type : liste
  • Obligatoire : vrai
• keysList
  • Liste de noms de clés séparés par des virgules.
  • Type : chaîne
  • Obligatoire : vrai
• stopAtFirstFound
  • Valeur booléenne indiquant s'il faut vérifier uniquement la première occurrence de la valeur de clé dans un instantané.
  • Valeur par défaut : vrai
  • Type : vrai | faux
  • Obligatoire : vrai
• caseSensitive
  • Valeur booléenne pour indiquer si la comparaison de clé est sensible à la casse.
  • Valeur par défaut : vrai
  • Type : vrai | faux
  • Obligatoire : faux

Valeur de clé unique (uniqueKeyValue)

Vérifie si la valeur de clé est différente pour une clé lorsque la clé a plusieurs occurrences dans un instantané.

Entraîne un statut non conforme lorsqu'une clé a la même valeur dans plusieurs occurrences.

Argument d'entrée

keyList

• Liste de noms de clés séparés par des virgules.
• Obligatoire : vrai
• Type : chaîne

Valeurs uniques entre les éléments déployables (checkUniqueKeyValue_crossDeployables)

Vérifie si toutes les clés fournies en tant qu'argument d'entrée keyName ont des valeurs différentes dans les éléments déployables.

Entraîne un statut non conforme lorsque la valeur d'une clé est identique dans plusieurs éléments déployables ou entraîne un avertissement lorsque le nom de clé spécifié dans l'entrée n'est trouvé dans aucun des éléments déployables.

Cas d'utilisation : détecter tout décalage de configuration entre les environnements de préparation et de production.

Arguments d'entrée

• additionalDeployablesInput
  • Liste d'éléments déployables supplémentaires à comparer avec l'élément déployable principal.
  • Type : liste
  • Obligatoire : vrai
• keyName
  • Liste de noms de clés séparés par des virgules.
  • Type : chaîne
  • Obligatoire : vrai

Variables non résolues (unresolvedVariables)

Vérifie s'il existe des variables non résolues dans un instantané.

Entraîne un statut non conforme lorsqu'une variable utilisée dans une valeur de clé ne peut pas être résolue.

Cas d'utilisation : s'assurer que toutes les variables utilisées dans les paramètres des données de configuration sont remplacées par une valeur, car toute variable non résolue peut interrompre l'opération de déploiement.