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 plantillas como desees en una configuración.

Las plantillas te permiten dividir la configuración en partes distintas que puedes usar y volver a usar 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 de entorno, los módulos y otras funcionalidades para crear archivos de plantillas y configuración dinámicos.

Para ver ejemplos de plantillas que puede usar en tus propias implementaciones, consulta el repositorio de GitHub de Deployment Manager.

Antes de comenzar

• Si deseas usar los ejemplos de línea de comandos de esta guía, instala la herramienta de línea de comandos de gcloud.
• Si deseas usar los ejemplos de la API en esta guía, configura el acceso a la API.
• Aprende a crear una configuración básica.

Sintaxis de plantilla

Las plantillas se pueden escribir en Jinja 2.10.x o Python 3.x. 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 las plantillas de Jinja y Python. Puedes importar plantillas en ambos lenguajes con 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-11
    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 archivo nuevo de Jinja o Python.

En los siguientes fragmentos, se muestran las secciones de plantillas que pueden simplificar tu implementación. Para ver las plantillas completas, haz clic en Ver en GitHub.

- 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-11
    networkInterfaces:
    - network: global/networks/default

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-11'
            }
        }],
        'networkInterfaces': [{
            'network': 'global/networks/default'
        }]
    }
})

Importa la plantilla

Después de crear una plantilla, debes importarla al archivo de configuración para 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 archivo larga, puedes brindar una propiedad de name opcional como alias del archivo. Puedes usar este nombre para hacer referencia a la plantilla más adelante. 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, sin importar 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:

imports:
- path: vm-template.jinja

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

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, Deployment Manager ofrece la posibilidad de implementar una plantilla directamente en Google Cloud CLI.

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 de plantilla, también puedes establecer estas propiedades 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, agrega comillas simples escapadas alrededor del valor, version: \'3\'.

• 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 creó con la consola de Google Cloud o gcloud CLI. Para obtener más información sobre cómo ver una implementación, lee Ve un manifiesto.

¿Qué sigue?

• A fin de ver ejemplos de plantillas listas para producción, consulta los ejemplos de Cloud Foundation Toolkit en GitHub.
• Usa las propiedades de las plantillas para comprimir todavía más tu contenido.
• Propaga la información sobre los proyectos y las implementaciones con las variables de entorno.
• Agrega una plantilla de forma permanente a tu proyecto como un tipo compuesto.