2.8. Créer et utiliser des cartes de configuration


Les sections suivantes définissent les cartes de configuration et expliquent comment les créer et les utiliser.

2.8.1. Comprendre les cartes de configuration

De nombreuses applications doivent être configurées à l'aide d'une combinaison de fichiers de configuration, d'arguments de ligne de commande et de variables d'environnement. Dans OpenShift Container Platform, ces artefacts de configuration sont découplés du contenu de l'image afin de maintenir la portabilité des applications conteneurisées.

L'objet ConfigMap fournit des mécanismes pour injecter des conteneurs avec des données de configuration tout en gardant les conteneurs agnostiques de OpenShift Container Platform. Une carte de configuration peut être utilisée pour stocker des informations fines comme des propriétés individuelles ou des informations grossières comme des fichiers de configuration entiers ou des blobs JSON.

L'objet API ConfigMap contient des paires clé-valeur de données de configuration qui peuvent être consommées dans des pods ou utilisées pour stocker des données de configuration pour des composants système tels que des contrôleurs. Par exemple, l'objet

ConfigMap Définition de l'objet

kind: ConfigMap
apiVersion: v1
metadata:
  creationTimestamp: 2016-02-18T19:14:38Z
  name: example-config
  namespace: default
data: 1
  example.property.1: hello
  example.property.2: world
  example.property.file: |-
    property.1=value-1
    property.2=value-2
    property.3=value-3
binaryData:
  bar: L3Jvb3QvMTAw 2

1 1
Contient les données de configuration.
2
Pointe vers un fichier qui contient des données non-UTF8, par exemple un fichier keystore Java binaire. Saisissez les données du fichier en base 64.
Note

Vous pouvez utiliser le champ binaryData lorsque vous créez une carte de configuration à partir d'un fichier binaire, tel qu'une image.

Les données de configuration peuvent être consommées dans les pods de différentes manières. Une carte de configuration peut être utilisée pour :

  • Remplir les valeurs des variables d'environnement dans les conteneurs
  • Définir les arguments de la ligne de commande dans un conteneur
  • Remplir les fichiers de configuration d'un volume

Les utilisateurs et les composants du système peuvent stocker des données de configuration dans une carte de configuration.

Une carte de configuration est similaire à un secret, mais elle est conçue pour faciliter le travail avec des chaînes de caractères qui ne contiennent pas d'informations sensibles.

Restrictions de la carte de configuration

A config map must be created before its contents can be consumed in pods.

Les contrôleurs peuvent être écrits de manière à tolérer les données de configuration manquantes. Consultez les composants individuels configurés à l'aide de cartes de configuration au cas par cas.

ConfigMap objects reside in a project.

Ils ne peuvent être référencés que par les pods du même projet.

The Kubelet only supports the use of a config map for pods it gets from the API server.

Cela inclut tous les pods créés en utilisant le CLI, ou indirectement à partir d'un contrôleur de réplication. Cela n'inclut pas les pods créés en utilisant le drapeau --manifest-url, le drapeau --config ou l'API REST du nœud OpenShift Container Platform, car ce ne sont pas des moyens courants de créer des pods.

2.8.2. Créer une carte de configuration dans la console web de OpenShift Container Platform

Vous pouvez créer une carte de configuration dans la console web d'OpenShift Container Platform.

Procédure

  • Pour créer une carte de configuration en tant qu'administrateur de cluster :

    1. Dans la perspective de l'administrateur, sélectionnez Workloads Config Maps.
    2. En haut à droite de la page, sélectionnez Create Config Map.
    3. Entrez le contenu de votre carte de configuration.
    4. Sélectionnez Create.
  • Pour créer une carte de configuration en tant que développeur :

    1. Dans la perspective du développeur, sélectionnez Config Maps.
    2. En haut à droite de la page, sélectionnez Create Config Map.
    3. Entrez le contenu de votre carte de configuration.
    4. Sélectionnez Create.

2.8.3. Création d'une carte de configuration à l'aide de la CLI

Vous pouvez utiliser la commande suivante pour créer une carte de configuration à partir de répertoires, de fichiers spécifiques ou de valeurs littérales.

Procédure

  • Créer une carte de configuration :

    oc create configmap <configmap_name> [options] $ oc create configmap <configmap_name> [options]

2.8.3.1. Création d'une carte de configuration à partir d'un répertoire

Vous pouvez créer une carte de configuration à partir d'un répertoire. Cette méthode vous permet d'utiliser plusieurs fichiers d'un répertoire pour créer une carte de configuration.

Procédure

L'exemple de procédure suivant explique comment créer une carte de configuration à partir d'un répertoire.

  1. Commencez par un répertoire contenant quelques fichiers qui contiennent déjà les données avec lesquelles vous voulez remplir une carte de configuration :

    $ ls example-files

    Exemple de sortie

    game.properties
    ui.properties

    $ cat example-files/game.properties

    Exemple de sortie

    enemies=aliens
    lives=3
    enemies.cheat=true
    enemies.cheat.level=noGoodRotten
    secret.code.passphrase=UUDDLRLRBABAS
    secret.code.allowed=true
    secret.code.lives=30

    $ cat example-files/ui.properties

    Exemple de sortie

    color.good=purple
    color.bad=yellow
    allow.textmode=true
    how.nice.to.look=fairlyNice

  2. Créez une carte de configuration contenant le contenu de chaque fichier de ce répertoire en entrant la commande suivante :

    $ oc create configmap game-config \
        --from-file=example-files/

    Lorsque l'option --from-file pointe vers un répertoire, chaque fichier directement dans ce répertoire est utilisé pour remplir une clé dans la carte de configuration, où le nom de la clé est le nom du fichier, et la valeur de la clé est le contenu du fichier.

    Par exemple, la commande précédente crée la carte de configuration suivante :

    $ oc describe configmaps game-config

    Exemple de sortie

    Name:           game-config
    Namespace:      default
    Labels:         <none>
    Annotations:    <none>
    
    Data
    
    game.properties:        158 bytes
    ui.properties:          83 bytes

    Vous pouvez voir que les deux clés de la carte sont créées à partir des noms de fichiers du répertoire spécifié dans la commande. Le contenu de ces clés pouvant être volumineux, la sortie de oc describe n'indique que les noms des clés et leur taille.

  3. Entrez la commande oc get pour l'objet avec l'option -o pour voir les valeurs des clés :

    $ oc get configmaps game-config -o yaml

    Exemple de sortie

    apiVersion: v1
    data:
      game.properties: |-
        enemies=aliens
        lives=3
        enemies.cheat=true
        enemies.cheat.level=noGoodRotten
        secret.code.passphrase=UUDDLRLRBABAS
        secret.code.allowed=true
        secret.code.lives=30
      ui.properties: |
        color.good=purple
        color.bad=yellow
        allow.textmode=true
        how.nice.to.look=fairlyNice
    kind: ConfigMap
    metadata:
      creationTimestamp: 2016-02-18T18:34:05Z
      name: game-config
      namespace: default
      resourceVersion: "407"
      selflink: /api/v1/namespaces/default/configmaps/game-config
      uid: 30944725-d66e-11e5-8cd0-68f728db1985

2.8.3.2. Création d'une carte de configuration à partir d'un fichier

Vous pouvez créer une carte de configuration à partir d'un fichier.

Procédure

L'exemple de procédure suivant explique comment créer une carte de configuration à partir d'un fichier.

Note

Si vous créez une carte de configuration à partir d'un fichier, vous pouvez inclure des fichiers contenant des données non-UTF8 qui sont placées dans ce champ sans corrompre les données non-UTF8. OpenShift Container Platform détecte les fichiers binaires et encode de manière transparente le fichier en tant que MIME. Sur le serveur, la charge utile MIME est décodée et stockée sans corrompre les données.

Vous pouvez transmettre l'option --from-file plusieurs fois à l'interface de programmation. L'exemple suivant donne des résultats équivalents à ceux de l'exemple de création à partir de répertoires.

  1. Créer une carte de configuration en spécifiant un fichier spécifique :

    $ oc create configmap game-config-2 \
        --from-file=example-files/game.properties \
        --from-file=example-files/ui.properties
  2. Vérifier les résultats :

    $ oc get configmaps game-config-2 -o yaml

    Exemple de sortie

    apiVersion: v1
    data:
      game.properties: |-
        enemies=aliens
        lives=3
        enemies.cheat=true
        enemies.cheat.level=noGoodRotten
        secret.code.passphrase=UUDDLRLRBABAS
        secret.code.allowed=true
        secret.code.lives=30
      ui.properties: |
        color.good=purple
        color.bad=yellow
        allow.textmode=true
        how.nice.to.look=fairlyNice
    kind: ConfigMap
    metadata:
      creationTimestamp: 2016-02-18T18:52:05Z
      name: game-config-2
      namespace: default
      resourceVersion: "516"
      selflink: /api/v1/namespaces/default/configmaps/game-config-2
      uid: b4952dc3-d670-11e5-8cd0-68f728db1985

Vous pouvez spécifier la clé à définir dans une carte de configuration pour le contenu importé à partir d'un fichier. Cette clé peut être définie en passant une expression key=value à l'option --from-file. Par exemple :

  1. Créer une carte de configuration en spécifiant une paire clé-valeur :

    $ oc create configmap game-config-3 \
        --from-file=game-special-key=example-files/game.properties
  2. Vérifier les résultats :

    $ oc get configmaps game-config-3 -o yaml

    Exemple de sortie

    apiVersion: v1
    data:
      game-special-key: |- 1
        enemies=aliens
        lives=3
        enemies.cheat=true
        enemies.cheat.level=noGoodRotten
        secret.code.passphrase=UUDDLRLRBABAS
        secret.code.allowed=true
        secret.code.lives=30
    kind: ConfigMap
    metadata:
      creationTimestamp: 2016-02-18T18:54:22Z
      name: game-config-3
      namespace: default
      resourceVersion: "530"
      selflink: /api/v1/namespaces/default/configmaps/game-config-3
      uid: 05f8da22-d671-11e5-8cd0-68f728db1985

    1
    Il s'agit de la clé que vous avez définie à l'étape précédente.

2.8.3.3. Création d'une carte de configuration à partir de valeurs littérales

Vous pouvez fournir des valeurs littérales pour une carte de configuration.

Procédure

L'option --from-literal utilise une syntaxe key=value qui permet de fournir des valeurs littérales directement sur la ligne de commande.

  1. Créer une carte de configuration en spécifiant une valeur littérale :

    $ oc create configmap special-config \
        --from-literal=special.how=very \
        --from-literal=special.type=charm
  2. Vérifier les résultats :

    $ oc get configmaps special-config -o yaml

    Exemple de sortie

    apiVersion: v1
    data:
      special.how: very
      special.type: charm
    kind: ConfigMap
    metadata:
      creationTimestamp: 2016-02-18T19:14:38Z
      name: special-config
      namespace: default
      resourceVersion: "651"
      selflink: /api/v1/namespaces/default/configmaps/special-config
      uid: dadce046-d673-11e5-8cd0-68f728db1985

2.8.4. Cas d'utilisation : Consommer des cartes de configuration dans les pods

Les sections suivantes décrivent quelques cas d'utilisation des objets ConfigMap dans les pods.

2.8.4.1. Remplir les variables d'environnement dans les conteneurs à l'aide de cartes de configuration

Les cartes de configuration peuvent être utilisées pour remplir des variables d'environnement individuelles dans des conteneurs ou pour remplir des variables d'environnement dans des conteneurs à partir de toutes les clés qui forment des noms de variables d'environnement valides.

Prenons l'exemple de la carte de configuration suivante :

ConfigMap avec deux variables d'environnement

apiVersion: v1
kind: ConfigMap
metadata:
  name: special-config 1
  namespace: default 2
data:
  special.how: very 3
  special.type: charm 4

1
Nom de la carte de configuration.
2
Le projet dans lequel se trouve la carte de configuration. Les cartes de configuration ne peuvent être référencées que par les pods du même projet.
3 4
Variables d'environnement à injecter.

ConfigMap avec une variable d'environnement

apiVersion: v1
kind: ConfigMap
metadata:
  name: env-config 1
  namespace: default
data:
  log_level: INFO 2

1
Nom de la carte de configuration.
2
Variable d'environnement à injecter.

Procédure

  • Vous pouvez consommer les clés de ce ConfigMap dans un pod en utilisant les sections configMapKeyRef.

    Exemple de spécification Pod configurée pour injecter des variables d'environnement spécifiques

    apiVersion: v1
    kind: Pod
    metadata:
      name: dapi-test-pod
    spec:
      containers:
        - name: test-container
          image: gcr.io/google_containers/busybox
          command: [ "/bin/sh", "-c", "env" ]
          env: 1
            - name: SPECIAL_LEVEL_KEY 2
              valueFrom:
                configMapKeyRef:
                  name: special-config 3
                  key: special.how 4
            - name: SPECIAL_TYPE_KEY
              valueFrom:
                configMapKeyRef:
                  name: special-config 5
                  key: special.type 6
                  optional: true 7
          envFrom: 8
            - configMapRef:
                name: env-config 9
      restartPolicy: Never

    1
    Stanza pour extraire les variables d'environnement spécifiées d'un site ConfigMap.
    2
    Nom de la variable d'environnement du pod dans laquelle vous injectez la valeur de la clé.
    3 5
    Nom de l'adresse ConfigMap à partir de laquelle des variables d'environnement spécifiques doivent être extraites.
    4 6
    Variable d'environnement à extraire de ConfigMap.
    7
    Rend la variable d'environnement facultative. En tant qu'optionnel, le pod sera démarré même si les ConfigMap et les clés spécifiés n'existent pas.
    8
    Stanza pour extraire toutes les variables d'environnement d'un site ConfigMap.
    9
    Nom de l'adresse ConfigMap à partir de laquelle toutes les variables d'environnement doivent être extraites.

    Lorsque ce module est exécuté, les journaux du module incluent la sortie suivante :

    SPECIAL_LEVEL_KEY=very
    log_level=INFO
Note

SPECIAL_TYPE_KEY=charm n'est pas listé dans l'exemple de sortie car optional: true est activé.

2.8.4.2. Définition des arguments de ligne de commande pour les commandes de conteneurs avec les cartes de configuration

Une carte de configuration peut également être utilisée pour définir la valeur des commandes ou des arguments dans un conteneur. Pour ce faire, on utilise la syntaxe de substitution de Kubernetes $(VAR_NAME). Considérons la carte de configuration suivante :

apiVersion: v1
kind: ConfigMap
metadata:
  name: special-config
  namespace: default
data:
  special.how: very
  special.type: charm

Procédure

  • Pour injecter des valeurs dans une commande dans un conteneur, vous devez consommer les clés que vous souhaitez utiliser comme variables d'environnement, comme dans le cas d'utilisation de ConfigMaps dans des variables d'environnement. Vous pouvez ensuite y faire référence dans la commande d'un conteneur à l'aide de la syntaxe $(VAR_NAME).

    Exemple de spécification Pod configurée pour injecter des variables d'environnement spécifiques

    apiVersion: v1
    kind: Pod
    metadata:
      name: dapi-test-pod
    spec:
      containers:
        - name: test-container
          image: gcr.io/google_containers/busybox
          command: [ "/bin/sh", "-c", "echo $(SPECIAL_LEVEL_KEY) $(SPECIAL_TYPE_KEY)" ] 1
          env:
            - name: SPECIAL_LEVEL_KEY
              valueFrom:
                configMapKeyRef:
                  name: special-config
                  key: special.how
            - name: SPECIAL_TYPE_KEY
              valueFrom:
                configMapKeyRef:
                  name: special-config
                  key: special.type
      restartPolicy: Never

    1
    Injectez les valeurs dans une commande dans un conteneur en utilisant les clés que vous souhaitez utiliser comme variables d'environnement.

    Lorsque ce module est exécuté, la sortie de la commande echo exécutée dans le conteneur test-container est la suivante :

    very charm

2.8.4.3. Injecter du contenu dans un volume en utilisant des cartes de configuration

Vous pouvez injecter du contenu dans un volume en utilisant des cartes de configuration.

Exemple ConfigMap ressource personnalisée (CR)

apiVersion: v1
kind: ConfigMap
metadata:
  name: special-config
  namespace: default
data:
  special.how: very
  special.type: charm

Procédure

Vous disposez de plusieurs options pour injecter du contenu dans un volume à l'aide de cartes de configuration.

  • La façon la plus simple d'injecter du contenu dans un volume à l'aide d'une carte de configuration consiste à remplir le volume avec des fichiers dont la clé est le nom et le contenu la valeur de la clé :

    apiVersion: v1
    kind: Pod
    metadata:
      name: dapi-test-pod
    spec:
      containers:
        - name: test-container
          image: gcr.io/google_containers/busybox
          command: [ "/bin/sh", "cat", "/etc/config/special.how" ]
          volumeMounts:
          - name: config-volume
            mountPath: /etc/config
      volumes:
        - name: config-volume
          configMap:
            name: special-config 1
      restartPolicy: Never
    1
    Fichier contenant la clé.

    Lorsque ce pod est exécuté, la sortie de la commande cat sera la suivante :

    very
  • Vous pouvez également contrôler les chemins à l'intérieur du volume où les clés de configuration sont projetées :

    apiVersion: v1
    kind: Pod
    metadata:
      name: dapi-test-pod
    spec:
      containers:
        - name: test-container
          image: gcr.io/google_containers/busybox
          command: [ "/bin/sh", "cat", "/etc/config/path/to/special-key" ]
          volumeMounts:
          - name: config-volume
            mountPath: /etc/config
      volumes:
        - name: config-volume
          configMap:
            name: special-config
            items:
            - key: special.how
              path: path/to/special-key 1
      restartPolicy: Never
    1
    Chemin d'accès à la clé de la carte de configuration.

    Lorsque ce pod est exécuté, la sortie de la commande cat sera la suivante :

    very
Red Hat logoGithubRedditYoutubeTwitter

Apprendre

Essayez, achetez et vendez

Communautés

À propos de la documentation Red Hat

Nous aidons les utilisateurs de Red Hat à innover et à atteindre leurs objectifs grâce à nos produits et services avec un contenu auquel ils peuvent faire confiance.

Rendre l’open source plus inclusif

Red Hat s'engage à remplacer le langage problématique dans notre code, notre documentation et nos propriétés Web. Pour plus de détails, consultez leBlog Red Hat.

À propos de Red Hat

Nous proposons des solutions renforcées qui facilitent le travail des entreprises sur plusieurs plates-formes et environnements, du centre de données central à la périphérie du réseau.

© 2024 Red Hat, Inc.