Politiques génériques dans DevOps Config

  • Rversion finale: Zurich
  • Mis à jour 31 juil. 2025
  • 27 minutes de lecture

    • Par défaut, le DevOps Config pack de contenu Policy contient un ensemble de politiques génériques pour valider vos données de configuration.

    Important :
    DevOps Config est désormais obsolète et n’est plus pris en charge ni disponible pour une nouvelle activation.
    Vous pouvez utiliser ou personnaliser ces politiques par défaut DevOps Config pour valider que le contenu de vos données de configuration est conforme, ou Administrer le cycle de vie complet de PaCE politiques.
    Remarque :
    Vous ne pouvez pas modifier les politiques par défaut. Toutefois, vous pouvez faire une copie de la politique et personnaliser votre copie.
    Tableau 1. Navigation dans la première lettre des polices sur cette page

    Un | C | D | F | L | K | L | M | N | L | u

    Comparateur de toutes les valeurs clés (allKeysValuesComparator)

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

    Entraîne un statut non conforme pour les conditions suivantes :
    • Lorsqu’une clé est présente dans le déployable principal mais pas dans les déployables supplémentaires.
    • Lorsqu’une clé est présente dans les éléments déployables supplémentaires, mais pas dans l’élément déployable principal.
    • Lorsqu’une clé est présente dans les déployables principaux et supplémentaires, mais avec des valeurs différentes

    Cas d’utilisation : Détecter toute dérive de configuration entre les environnements de stockage intermédiaire 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 pour indiquer 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 : true | false
      • Obligatoire : faux
    • exceptionList
      • Une liste de noms de clés séparés par des virgules qui doivent être ignorés lors de la comparaison.
      • Type : chaîne
      • Obligatoire : faux

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

    Vérifie si une valeur de domaine d’e-mail identifiée en fonction 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êchez les données (sensibles) de quitter un domaine d’e-mail professionnel approuvé.

    Arguments d'entrée
    • authorizedDomains
      • Une liste séparée par des virgules des domaines d’e-mail autorisés.
      • Exemple :
        gmail.com,servicenow.com
      • Type : chaîne
      • Obligatoire : vrai
    • exceptionList
      • Une 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 URL d’un instantané ne sont pas conformes au format spécifié pour le composant hôte.

    Cas d’utilisation : empêchez l’exposition de données (sensibles) via des URL non autorisées.

    Arguments d'entrée
    • authorizedHostsRegex
      • Une liste séparée par des virgules d’expressions régulières utilisées pour valider le composant hôte dans les URL.
      • Exemple : 
        notpresent$,code.devsnc+,mydomain.com
      • Type : chaîne
      • Obligatoire : vrai
    • exceptionList
      • Une 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 (KVCombinations autorisées)

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

    Entraîne un statut de non-réclamation lorsqu’une clé a une valeur non autorisée.

    Arguments d'entrée
    • authorisedList
      • Liste JSON de 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é utilisées pour la validation sont sensibles à la casse.
      • Valeur par défaut : faux
      • Type : true | false
      • 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-réclamation lorsqu’une valeur de port n’est pas dans la plage acceptable.

    Cas d’utilisation : vérifiez que les noms de port se trouvent dans la plage acceptable pour l’environnement dans lequel ils sont utilisés. La politique peut être utilisée pour n’importe quelle vérification de valeur de plage, pas seulement pour les numéros de port. Par exemple, pour vérifier que tous les paramètres définissant une taille de tas se trouvent dans la plage appropriée.
    Arguments d'entrée
    • keysRegexWithRange
      • Une liste JSON des clés de port et de la plage de ports avec les valeurs minimale et maximale. Une clé est identifiée comme port lorsque la clé correspond aux expressions régulières spécifiées dans l’entrée.
      • Exemple :
        { 
  "^web_port$": "5000-5003",
  "env.db.port": "10000-65535"
}
      • Type : JSON
      • Obligatoire : vrai
    • exceptionList
      • Une liste de noms de clés séparés par des virgules qui sont ignorés par la politique.
      • Type : chaîne
      • Obligatoire : faux

    Validateur de certificat (certificateValidator)

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

    Entraîne un statut non conforme lorsque la clé de date d’expiration ou la clé de 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 additionnée des 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 additionnée des jours d’expiration.
      • Type : entier
      • Obligatoire : faux
    • exceptionList
      • Liste de noms de certificats, 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-réclamation 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 d’ordinateurs virtuels, ils ont la même configuration.

    Argument d’entrée
    exceptionList
    • Une liste séparée par des virgules de nœuds ou de combinaisons clé-valeur à 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 est autorisé à utiliser.

    Entraîne un statut de non-réclamation lorsqu’une clé avec une valeur 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
      • Une 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 de variables d’un 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é.

    Différents noms de clés Mêmes valeurs (differentKeyNamesSameValues)

    Vérifie si les valeurs sont les mêmes 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 : Obtenez un contrôle plus fin 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 plus de deux 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é.

    Entraîne un statut non conforme lorsqu’une clé a la même valeur dans plusieurs composants.
    Remarque :
    Si une clé a plusieurs occurrences dans le même composant, utilisez la politique de valeur de clé unique (uniqueKeyValue).
    Argument d’entrée
    keynameList
    • Une 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 vous assurer 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
      • Une valeur regex pour une image de Docker.
        Exemple de valeur d’entrée pour s’assurer 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 séparée par des virgules des services qui sont exemptés de la validation.
      • Type : chaîne
      • Obligatoire : faux

    Validateur du registre d’images de Docker (dockerImageRegistryValidator)

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

    Analyse l’image de 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 ne figure 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 du 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é n’est labels/com.docker.lb.network pas défini dans la section de niveau de service et la section de réseau de niveau supérieur.

    Valeurs en double (duplicateValues)

    Recherche 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’exceptions.

    Cas d’utilisation : obtenez 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 pour indiquer s’il faut inclure le chemin d’accès complet du nœud dans la sortie.
      • Valeur par défaut : true
      • Type : true | false
      • Obligatoire : vrai
    • pathSeparator
      • Chaîne indiquant le séparateur de chemin d’accès pour les nœuds.
      • Valeur par défaut : /
      • Type : chaîne
      • Obligatoire : vrai
    • exceptionList
      • Un tableau de chaînes à exclure de la validation.
      • Valeur par défaut : ["true », « false », « yes », « no », « enabled », « disabled"]
      • 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-réclamation lorsqu’une clé trouvée dans un instantané a une valeur interdite comme spécifié dans la liste d’entrées.

    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 clés d’un instantané avec la liste de valeurs fournies dans l’entrée. La valeur 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 pour 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ées.
    • 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ées.
    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,CONTIENT,NE CONTIENT PAS et EST ÉGAL.
      • Exemple de valeur d’entrée à appliquer qu’un utilisateur défini dans le chemin d’accès système /root/user est 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 : true
      • Type : true | false
      • 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 pour 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 n’est PAS DANS, 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 modèle 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 : true
      • Type : true | false
      • Obligatoire : faux

    Comparateur d’existence de clé (keyExistenceComparator)

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

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

    Cas d’utilisation : comparez vos variables d’environnement et vérifiez 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 pour indiquer s’il faut inclure des nœuds enfants d’éléments déployables lors de la comparaison.
      • Valeur par défaut : faux
      • Type : true | false
      • Obligatoire : faux
    • caseSensitive
      • Valeur booléenne pour indiquer si la comparaison de clés est sensible à la casse.
      • Valeur par défaut : faux
      • Type : true | false
      • Obligatoire : faux
    • exceptionList
      • Une liste de noms de clés séparés par des virgules qui doivent être ignorés lors de la comparaison.
      • Type : chaîne
      • Obligatoire : faux

    Convention de dénomination de clé (keyNamingConvention)

    Vérifie si les noms de clés suivent un modèle de nommage donné.

    Entraîne un statut de non-réclamation lorsque les clés ne suivent pas le modèle 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 indiquant les préfixes approuvés pour un nom de clé.
      • Type : tableau de chaînes
      • Obligatoire : faux
    • includePath
      • Valeur booléenne pour indiquer s’il faut inclure le chemin d’accès complet du nœud dans la sortie.
      • Valeur par défaut : true
      • Type : true | false
      • Obligatoire : vrai
    • approvedSuffixArray
      • Tableau de chaînes indiquant les suffixes approuvés pour un nom de clé.
      • Type : tableau de chaînes
      • Obligatoire : faux
    • exceptionList
      • Une liste de clés séparées par des virgules à exclure de la validation.
      • Type : chaîne
      • Obligatoire : faux

    Validateur de chemin de clé (keyPathValidator)

    Vérifie si une clé pour le chemin de clé spécifié est trouvée dans un instantané. 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-réclamation lorsque la clé du chemin de clé spécifié a une valeur non valide. En outre, si l’argument d’entrée ignoreIfNotFound est False, il en résulte un statut de non-réclamation lorsque le chemin d’accès de 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 d’accès 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 à la clé spécifié doit exister dans un instantané.
      • Valeur par défaut : true
      • Type : true | false
      • Obligatoire : faux

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

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

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

    Argument d’entrée
    keyNameWithKeyValues
    • Objet JSON qui contient un ensemble de sous-chaînes requis, y compris des paires de sous-chaînes de nom de clé et de sous-chaîne 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 est insensible à la casse.

    Entraîne un statut non conforme lorsque toutes les 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
      • Le nom clé du nœud principal.
      • Type : chaîne
      • Obligatoire : vrai
    • list2Node
      • Nom 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
      • Une 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és est sensible à la casse.
      • Valeur par défaut : faux
      • Type : true | false
      • 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 les valeurs 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
    • Un tableau des chemins d’accès clés et des valeurs minimales et maximales des limites d’unités de mémoire comme 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 nœuds de balises trouvés dans un instantané ont des valeurs autorisées.

    Entraîne un statut de non-réclamation lorsqu’une valeur d’un nœud de balise n’est pas incluse dans la liste des balises autorisées.
    Arguments d'entrée
    • tagsNodeName
      • Une liste de noms de clés séparés par des virgules.
      • Type : chaîne
      • Obligatoire : vrai
    • tagsList
      • Une liste séparée par des virgules des valeurs de balises autorisées.
      • Type : chaîne
      • Obligatoire : vrai
    • caseSensitive
      • Valeur booléenne pour indiquer si la comparaison de clés est sensible à la casse.
      • Valeur par défaut : faux
      • Type : true | false
      • Obligatoire : faux

    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 entraîne un avertissement lorsque le nom de clé spécifié dans l’entrée est introuvable dans un instantané.

    Arguments d'entrée
    • keysList
      • Une liste de noms de clés séparés par des virgules.
      • Type : chaîne
      • Obligatoire : vrai
    • stopAtFirstFound
      • Valeur booléenne pour indiquer s’il faut vérifier uniquement la première occurrence de la valeur de clé dans un instantané.
      • Valeur par défaut : true
      • Type : true | false
      • Obligatoire : vrai
    • trimValue
      • Valeur booléenne pour indiquer s’il faut supprimer des espaces de début ou de fin de la valeur de clé avant la comparaison.
      • Valeur par défaut : true
      • Type : true | false
      • Obligatoire : vrai
    • caseSensitive
      • Valeur booléenne pour indiquer si la comparaison de clés est sensible à la casse.
      • Valeur par défaut : faux
      • Type : true | false
      • 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.

    Entraîne un statut non conforme pour les conditions suivantes :
    • Lorsque la valeur d’une clé spécifiée dans l’argument d’entrée keyNamesString n’est pas une valeur de chaîne ou est vide.
    • Lorsque la valeur d’une clé spécifiée dans l’argument d’entrée keyNamesInteger n’est pas une valeur entière ou est vide.
    • Lorsque la valeur d’une clé spécifiée dans l’argument d’entrée keyNamesBoolean n’est pas une valeur booléenne ou est 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 claire (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 comparaison insensible à la casse.
      • Valeur par défaut : pass,pwd,secret
      • Type : chaîne
      • Obligatoire : vrai
    • exceptionList
      • Une liste de clés séparées par des virgules à exclure de la validation.
      • Type : chaîne
      • Obligatoire : faux

    Pas de clés 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é a plusieurs occurrences dans un instantané.

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

    Argument d’entrée
    keyNames
    • Une 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 pour indiquer s’il faut supprimer des espaces de début ou de fin de la valeur de clé avant la comparaison.
      • Valeur par défaut : true
      • Type : true | false
      • Obligatoire : vrai
    • caseSensitive
      • Valeur booléenne pour indiquer si la comparaison de clés est sensible à la casse.
      • Valeur par défaut : faux
      • Type : true | false
      • Obligatoire : faux
    • exceptionList
      • Une 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-réclamation lorsqu’une clé trouvée dans un instantané a une valeur interdite comme spécifié dans la liste d’entrées.

    Arguments d'entrée
    • forbiddenValues
      • Une liste de valeurs interdites séparées par des virgules.
      • Valeur par défaut : root
      • Type : chaîne
      • Obligatoire : faux
    • excludedKeyNames
      • Une 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 être présent 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és est sensible à la casse.
      • Valeur par défaut : faux
      • Type : true | false
      • Obligatoire : faux
    • exceptionList
      • Une 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 être présent 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és est sensible à la casse.
      • Valeur par défaut : faux
      • Type : true | false
      • Obligatoire : faux
    • exceptionList
      • Une 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 et vice versa.

    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 du nœud secondaire dans un instantané.
      • Valeur par défaut : []
      • Type : tableau de chaînes
      • Obligatoire : vrai
    • includePath
      • Valeur booléenne pour indiquer s’il faut inclure le chemin d’accès complet du nœud dans la sortie.
      • Valeur par défaut : true
      • Type : true | false
      • Obligatoire : faux

    Aucun 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 être présent 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és est sensible à la casse.
      • Valeur par défaut : faux
      • Type : true | false
      • Obligatoire : faux
    • exceptionList
      • Une 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é.

    Entraîne un statut non conforme pour les conditions suivantes :
    • Lorsqu’une clé spécifiée dans l’argument d’entrée sameValueKeys a une valeur différente dans deux nœuds.
    • Lorsqu’une clé spécifiée dans l’argument d’entrée diffValueKeys a la même valeur dans deux nœuds.
    • Lorsque l’argument d’entrée allowMissingKeys est défini sur False et si une clé est présente dans le nœud primaire mais pas dans le nœud secondaire ou vice versa.

    Cas d’utilisation : assurez la cohérence entre les nœuds en comparant les valeurs de 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 du nœud secondaire dans un instantané.
      • Valeur par défaut : []
      • Type : tableau de chaînes
      • Obligatoire : vrai
    • includePath
      • Valeur booléenne pour indiquer s’il faut inclure le chemin d’accès complet du nœud dans la sortie.
      • Valeur par défaut : true
      • Type : true | false
      • Obligatoire : faux
    • sameValueKeys
      • Une liste de noms de clés séparés par des virgules ayant les mêmes valeurs.
      • Type : chaîne
      • Obligatoire : faux
    • diffValueKeys
      • Une 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 les mêmes dans le nœud secondaire.
      • Valeur par défaut : faux
      • Type : true | false
      • Obligatoire : faux

    Aucun caractère d’espace vide autorisé (noWhiteSpaceAllowed)

    Vérifie si les valeurs de clé ne contiennent pas d’espaces, 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 d’espace.

    Cas d’utilisation : Empêchez les espaces blancs de causer des problèmes pour les outils ou les applications lorsque les paramètres sont appliqués.
    Argument d’entrée
    excludedKeyNames
    • Une liste de clés séparées par des virgules à exclure de la validation.
    • Valeur par défaut : description
    • Type : chaîne
    • Obligatoire : faux

    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
    • Une 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 déployables.

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

    Cas d’utilisation : Détecter toute dérive de configuration entre les environnements de stockage intermédiaire 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
      • Une liste de noms de clés séparés par des virgules.
      • Type : chaîne
      • Obligatoire : vrai
    • stopAtFirstFound
      • Valeur booléenne pour indiquer s’il faut vérifier uniquement la première occurrence de la valeur de clé dans un instantané.
      • Valeur par défaut : true
      • Type : true | false
      • Obligatoire : vrai
    • caseSensitive
      • Valeur booléenne pour indiquer si la comparaison de clés est sensible à la casse.
      • Valeur par défaut : true
      • Type : true | false
      • 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
    • Une liste de noms de clés séparés par des virgules.
    • Obligatoire : vrai
    • Type : chaîne

    Valeurs uniques parmi les 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 déployables.

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

    Cas d’utilisation : Détecter toute dérive de configuration entre les environnements de stockage intermédiaire 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
      • Une 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 : assurez-vous 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.