Créer un modèle de base

Un fichier de configuration de base peut suffire pour des charges de travail simples, mais lorsque vous avez affaire à des architectures plus complexes ou à des configurations que vous envisagez de réutiliser, vous pouvez diviser votre configuration en modèles.

Un modèle est un fichier distinct importé et utilisé en tant que type dans une configuration. Vous pouvez faire appel à autant de modèles que vous le souhaitez dans une configuration. Deployment Manager développera les modèles importés de manière récursive pour créer votre configuration complète.

Les modèles vous permettent de séparer votre configuration en plusieurs parties que vous pouvez utiliser à volonté dans différents déploiements. Vous pouvez choisir le degré de généralité ou de spécificité des modèles selon vos besoins. Les modèles vous permettent également de tirer parti de fonctionnalités telles que les propriétés de modèle, les variables d'environnement, les modules et d'autres fonctionnalités de modèle pour créer des fichiers de configuration et de modèle dynamiques.

Pour consulter des exemples de modèles que vous pouvez utiliser dans vos propres déploiements, accédez au dépôt GitHub de Deployment Manager.

Avant de commencer

Syntaxe du modèle

Les modèles peuvent être rédigés en Jinja 2.8 ou Python 2.7. La syntaxe de Jinja se rapproche davantage de YAML. Il peut donc être plus simple de rédiger des modèles en Jinja si vous êtes plus à l'aise avec YAML.

Vous pouvez également rédiger des fichiers de modèle en Python et générer des parties de vos modèles de manière automatisée dans ce langage. Vous pouvez par exemple mettre en forme des définitions de modèle à l'aide de bibliothèques Python. Si vous maîtrisez Python, ce format pourrait mieux vous correspondre.

Deployment Manager accepte les fichiers Jinja et Python. Vous pouvez utiliser la syntaxe que vous voulez en fonction de vos préférences. En outre, vous pouvez rédiger différents modèles en langage Jinja ou Python, puis importer les deux dans la même configuration.

Créer un modèle de base

Un modèle est un fichier que vous créez et qui est rédigé en Jinja ou en Python. Prenez par exemple le fichier de configuration suivant :

# Copyright 2016 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

resources:
- name: vm-created-by-deployment-manager
  type: compute.v1.instance
  properties:
    zone: us-central1-a
    machineType: zones/us-central1-a/machineTypes/n1-standard-1
    disks:
    - deviceName: boot
      type: PERSISTENT
      boot: true
      autoDelete: true
      initializeParams:
        sourceImage: projects/debian-cloud/global/images/family/debian-9
    networkInterfaces:
    - network: global/networks/default

Cette configuration est valide, mais vous pouvez la simplifier davantage en divisant plusieurs parties en fichiers de modèle individuels réutilisables. Pour créer un modèle basé sur la configuration ci-dessus, extrayez la section correspondant à la ressource en question et créez un nouveau fichier Jinja ou Python.

Jinja

- name: vm-template
  type: compute.v1.instance
  properties:
    zone: us-central1-a
    machineType: zones/us-central1-a/machineTypes/n1-standard-1
    disks:
    - deviceName: boot
      type: PERSISTENT
      boot: true
      autoDelete: true
      initializeParams:
        sourceImage: projects/debian-cloud/global/images/family/debian-9
    networkInterfaces:
    - network: global/networks/default

Python

Les modèles Python ne doivent remplir que deux conditions :

  • Le modèle doit définir une méthode appelée GenerateConfig() ou generate_config(). Si vous utilisez les deux noms de méthode dans le même modèle, la méthode generate_config() est prioritaire.
  • La méthode doit renvoyer une configuration YAML valide.

En dehors de ces exigences, vous pouvez générer le contenu de votre modèle comme vous l'entendez.

Exemple

resources.append({
    'name': 'vm-template',
    'type': 'compute.v1.instance',
    'properties': {
        'zone': 'us-central1-a',
        'machineType': 'zones/us-central1-a/machineTypes/n1-standard-1',
        'disks': [{
            'deviceName': 'boot',
            'type': 'PERSISTENT',
            'boot': True,
            'autoDelete': True,
            'initializeParams': {
                'sourceImage':
                    'projects/debian-cloud/global/images/family/debian-9'
            }
        }],
        'networkInterfaces': [{
            'network': 'global/networks/default'
        }]
    }
})

Pour obtenir l'exemple complet en Python, consultez le dépôt GitHub de Deployment Manager.

Importer le modèle

Après avoir créé un modèle, importez-le dans votre fichier de configuration afin de l'utiliser. Pour importer un modèle, ajoutez une section imports à votre configuration, suivie du chemin relatif ou absolu du répertoire actuel. Vous pouvez par exemple importer votre modèle de machine virtuelle créé à l'étape précédente en ajoutant la ligne suivante en haut de votre configuration :

imports:
  - path: path/to/my_vm_template.jinja

Si le chemin d'accès de votre fichier est long, vous pouvez fournir une propriété name facultative qui servira d'alias au fichier. Vous pourrez ensuite vous référer au modèle à l'aide de ce nom. Si vous ne fournissez pas de nom, le modèle peut être référencé grâce à la valeur path.

imports:
  - path: path/to/my_vm_template.jinja
    name: my_renamed_template.jinja

Vous pouvez importer une combinaison de plusieurs modèles, qu'ils soient rédigés en langage Jinja ou Python :

imports:
  - path: path/to/my_vm_template.jinja
    name: my_renamed_template.jinja
  - path: special_vm.py

Si votre modèle utilise d'autres modèles comme dépendances, importez également ces modèles dépendants dans votre configuration :

imports:
  - path: path/to/my_vm_template.jinja
  - path: special_vm.py
  - path: base_vm.jinja

Vous pouvez également importer des fichiers texte pour aligner le contenu. Par exemple, vous pouvez créer un fichier nommé resource_type.txt avec la chaîne suivante :

compute.v1.instance

Importez-le dans votre configuration et insérez le contenu aligné, comme le montre l'exemple ci-dessous :

imports:
- path: resource_type.txt

resources:
- name: my-vm
  type: {{ imports["resource_type.txt"] }} # Resolves to "compute.v1.instance"
  properties:
    zone: us-central1-a
    machineType: zones/us-central1-a/machineTypes/f1-micro
    disks:
    - deviceName: boot
      type: PERSISTENT
      boot: true
      autoDelete: true
      initializeParams:
        sourceImage: projects/debian-cloud/global/images/family/debian-9
    networkInterfaces:
    - network: global/networks/default
      accessConfigs:
      - name: External NAT
        type: ONE_TO_ONE_NAT

Déployer des modèles

Une fois que vous avez importé un modèle, vous pouvez l'utiliser en tant que type dans votre configuration :

Jinja

imports:
- path: vm-template.jinja

resources:
- name: my-vm
  type: vm-template.jinja

Python

imports:
- path: vm-template.py

resources:
- name: my-vm
  type: vm-template.py

Si vous n'avez pas défini de nom pour votre modèle, appelez-le à l'aide du chemin :

imports:
- path: path/to/my_vm_template.jinja

resources:
- name: my-first-virtual-machine
  type: path/to/my_vm_template.jinja

Déployer des modèles directement avec l'outil de ligne de commande

Plutôt que de créer un fichier de configuration de premier niveau, Deployment Manager permet de déployer un modèle directement dans l'outil de ligne de commande gcloud.

Par exemple, la requête suivante déploie un modèle appelé vm_template.jinja :

gcloud deployment-manager deployments create a-single-vm --template vm_template.jinja

Si votre modèle dispose de propriétés de modèle, vous pouvez également les définir dans la ligne de commande à l'aide de l'indicateur --properties :

gcloud deployment-manager deployments create my-igm \
    --template vm_template.jinja \
    --properties zone:us-central1-a

Points à noter :

  • Toutes les valeurs sont analysées en tant que valeurs YAML. Par exemple, la valeur version: 3 est transmise au format d'entier. Si vous souhaitez la définir en tant que chaîne, placez des guillemets simples autour de la valeur : version: \'3\'.

  • Les valeurs booléennes ne sont pas sensibles à la casse. Les valeurs TRUE, true et True sont donc traitées de la même manière.

  • Vous devez transmettre toutes les propriétés requises définies par le modèle. Vous ne pouvez pas vous limiter à un sous-ensemble des propriétés. Si certaines propriétés possèdent des valeurs par défaut, vous pouvez les omettre dans la ligne de commande.

Pour spécifier plusieurs propriétés, fournissez des paires valeur/clé séparées par des virgules. L'ordre dans lequel vous spécifiez les valeurs n'a pas d'importance. Exemple :

gcloud deployment-manager deployments create my-igm 
--template vm_template.jinja
--properties zone:us-central1-a,machineType:n1-standard-1,image:debian-9

Une fois cette commande exécutée, Deployment Manager crée un déploiement à partir du modèle fourni. Vous pouvez confirmer que le déploiement a bien été créé à l'aide de la console Google Cloud Platform ou de l'outil gcloud. Pour savoir comment afficher un déploiement, consultez la section Afficher un fichier manifeste.

Étape suivante

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Documentation Cloud Deployment Manager