Crea una plantilla básica

Es posible que un archivo de configuración básica sea suficiente para las cargas de trabajo simples, pero te recomendamos separar la configuración en plantillas cuando se trate de arquitecturas más complejas o de configuraciones que deseas reutilizar.

Una plantilla es un archivo independiente que se importa y usa como tipo de configuración. Puedes usar tantas como gustes en una configuración. Además, Deployment Manager ampliará recurrentemente las plantillas importadas para crear tu configuración completa.

Las plantillas te permiten dividir la configuración en partes distintas que puedes usar y reutilizar en implementaciones diferentes. Pueden ser específicas o generalizadas, según lo necesites. Con ellas, también puedes aprovechar funciones como las propiedades de las plantillas, las variables del entorno, los módulos y otras funcionalidades para crear archivos de plantillas y configuración dinámicos.

Antes de comenzar

Sintaxis de plantilla

Las plantillas se pueden escribir en Jinja 2.8 o Python 2.7. Jinja se asemeja más a la sintaxis de YAML, por lo que, si conoces este lenguaje, te resultará más sencillo escribir las plantillas en Jinja.

También puedes escribir los archivos de plantillas en Python para aprovechar la generación de manera programática de algunas partes de las plantillas. Por ejemplo, puedes usar las bibliotecas de Python para dar formato a las definiciones de plantillas. Si estás familiarizado con este lenguaje, es posible que sea el mejor formato para ti.

Deployment Manager acepta archivos de Jinja y Python, por lo que puedes usar la sintaxis que prefieras. Además, puedes mezclar distintas plantillas, escribirlas en Jinja o Python y, luego, importarlas en la misma configuración.

Crea una plantilla básica

Una plantilla es un archivo que creas y escribes en Python o Jinja. Por ejemplo, considera el siguiente archivo de configuración:

# 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

Esta configuración es válida, pero puedes simplificarla si la divides en distintas partes como archivos de plantillas individuales que puedes reutilizar. Para crear una plantilla basada en la configuración anterior, debes extraer una sección del recurso en cuestión y crear un nuevo archivo de Jinja o 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

Las plantillas de Python solo tienen dos requisitos:

  • La plantilla debe definir un método llamado GenerateConfig() o generate_config(). Si usas ambos nombres de métodos en la misma plantilla, el método generate_config() tendrá prioridad.
  • El método debe mostrar una configuración de YAML válida.

Aparte de eso, puedes decidir sobre el contenido que generarás para tu plantilla.

Ejemplo

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'
        }]
    }
})

Para ver el ejemplo completo de Python, consulta el repositorio de GitHub de Deployment Manager.

Importa la plantilla

Después de crear una plantilla, debes importarla al archivo de configuración a fin de usarla. Para importar una plantilla, agrega una sección imports a tu configuración, seguido de una ruta absoluta o relativa desde el directorio actual. Por ejemplo, puedes importar la plantilla de tu máquina virtual del paso anterior si agregas la siguiente línea a la parte superior de tu configuración:

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

Si tienes una ruta de acceso al archivo larga, puedes brindar una propiedad de name opcional como alias del archivo y usar ese nombre para hacer referencia a la plantilla después. Si no incluyes un nombre, se puede hacer referencia a la plantilla con la path.

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

Puedes combinar importaciones de varias plantillas, independiente de si son de Jinja o Python.

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

Si tu plantilla usa otras plantillas como dependencias, importa las dependientes en tu configuración:

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

También puedes importar archivos de texto para intercalar el contenido. Por ejemplo, si creas un archivo llamado “tipo_de_recurso.txt” con la siguiente string:

compute.v1.instance

Impórtalo en la configuración y brinda el intercalado de contenido de la siguiente manera:

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

Implementa plantillas

Después de importar una plantilla, úsala como tipo en tu configuración:

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 no proporcionaste un nombre para la plantilla, llámala con la ruta de acceso:

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

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

Implementa plantillas directamente con la herramienta de línea de comandos

En lugar de crear un archivo de configuración de nivel superior, en Deployment Manager puedes implementar una plantilla directamente en herramienta de línea de comandos de gcloud.

Por ejemplo, la siguiente solicitud implementa una plantilla llamada vm_template.jinja:

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

Si tu plantilla tiene propiedades, también puedes configurarlas en la línea de comandos con la marca --properties:

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

Ten en cuenta lo siguiente:

  • Todos los valores se analizan como valores de YAML. Por ejemplo, version: 3 se pasa como un número entero. Si deseas especificarlo como una string, escribe el valor version: \'3\' entre comillas simples escapadas.

  • Los valores booleanos no distinguen entre mayúsculas y minúsculas, por lo que TRUE, true y True se tratan de la misma manera.

  • Debes pasar todas las propiedades obligatorias que definió la plantilla. No puedes proporcionar solo un subconjunto de las propiedades. Si determinadas propiedades tienen valores predeterminados, puedes omitir la propiedad en la línea de comandos.

Para especificar varias propiedades, proporciona pares clave-valor separados por comas. No importa en qué orden especifiques los pares. Por ejemplo:

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

Después de ejecutar este comando, Deployment Manager crea una implementación con la plantilla que proporcionaste. Puedes confirmar que la implementación se haya creado con Google Cloud Platform Console o la herramienta de gcloud. Para obtener más información sobre cómo ver una implementación, consulta Ve un manifiesto.

¿Qué sigue?

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Cloud Deployment Manager Documentation