Crear una aplicación de libro de registro con balanceo de carga de HTTP

En este ejemplo avanzado se muestra cómo crear una aplicación de registro que usa Node.js para el frontend y MySQL para el backend. La plantilla también crea y conecta un balanceador de carga HTTP que balancea la carga entre dos zonas, así como un escalador automático para escalar la aplicación automáticamente.

Recursos de implementación con balanceo de carga de HTTP
Recursos de implementación con balanceo de carga de HTTP (haz clic para ampliar)

En este ejemplo, se da por hecho que conoces los contenedores Docker y los recursos de Compute Engine, en concreto el balanceo de carga HTTP, el autoescalado, los grupos de instancias gestionados y las plantillas de instancia.

Para ver más tutoriales de introducción, consulta la guía de inicio o la guía paso a paso.

Antes de empezar

Crear plantillas

En este ejemplo se inicia una implementación con varios tipos de recursos. Para empezar, crea plantillas reutilizables que definan estos recursos por separado. Más adelante, utilizarás estas plantillas en la configuración final.

Al final de este ejemplo, tendrás una implementación que contenga estos recursos:

  • Una sola instancia de Compute Engine para la máquina virtual MySQL de backend.
  • Una plantilla de instancia que usa una imagen de Docker.
  • Dos grupos de instancias gestionados con escalado automático en dos zonas diferentes que ejecutan el servicio frontend de Node.js.
  • Otros dos grupos de instancias gestionados autoescalados que sirven datos estáticos.
  • Una comprobación del estado y un balanceador de carga HTTP para distribuir el tráfico entre los grupos de instancias gestionadas correspondientes.

Crear las plantillas de backend

El backend de esta aplicación es una única instancia de Compute Engine que ejecuta un contenedor de Docker de MySQL. Crea una plantilla que defina una instancia de Compute Engine que utilice una imagen optimizada para contenedores. Ponle el nombre container_vm.[py|jinja] al archivo:

Jinja 



{% from 'container_helper.jinja' import GenerateManifest %}
{% set COMPUTE_URL_BASE = 'https://www.googleapis.com/compute/v1/' %}

resources:
- name: {{ env['name'] }}
  type: compute.v1.instance
  properties:
    zone: {{ properties['zone'] }}
    machineType: {{ COMPUTE_URL_BASE }}projects/{{ env['project'] }}/zones/{{ properties['zone'] }}/machineTypes/f1-micro
    metadata:
      items:
      - key: gce-container-declaration
        value: |
          {{ GenerateManifest(env['name'], properties['port'], properties['dockerImage'], properties['dockerEnv'])|indent(10) }}
    disks:
    - deviceName: boot
      type: PERSISTENT
      autoDelete: true
      boot: true
      initializeParams:
        diskName: {{ env['name'] }}-disk
        sourceImage: {{ COMPUTE_URL_BASE }}projects/cos-cloud/global/images/{{ properties['containerImage'] }}
    networkInterfaces:
    - accessConfigs:
      - name: external-nat
        type: ONE_TO_ONE_NAT
      network: {{ COMPUTE_URL_BASE }}projects/{{ env['project'] }}/global/networks/default
    serviceAccounts:
      - email: default
        scopes:
        - https://www.googleapis.com/auth/logging.write
        - https://www.googleapis.com/auth/monitoring.write

Python 

# 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.

"""Creates a Container VM with the provided Container manifest."""

from container_helper import GenerateManifest


COMPUTE_URL_BASE = 'https://www.googleapis.com/compute/v1/'


def GlobalComputeUrl(project, collection, name):
  return ''.join([COMPUTE_URL_BASE, 'projects/', project,
                  '/global/', collection, '/', name])


def ZonalComputeUrl(project, zone, collection, name):
  return ''.join([COMPUTE_URL_BASE, 'projects/', project,
                  '/zones/', zone, '/', collection, '/', name])


def GenerateConfig(context):
  """Generate configuration."""

  base_name = context.env['name']

  # Properties for the container-based instance.
  instance = {
      'zone': context.properties['zone'],
      'machineType': ZonalComputeUrl(context.env['project'],
                                     context.properties['zone'],
                                     'machineTypes',
                                     'f1-micro'),
      'metadata': {
          'items': [{
              'key': 'gce-container-declaration',
              'value': GenerateManifest(context)
              }]
          },
      'disks': [{
          'deviceName': 'boot',
          'type': 'PERSISTENT',
          'autoDelete': True,
          'boot': True,
          'initializeParams': {
              'diskName': base_name + '-disk',
              'sourceImage': GlobalComputeUrl('cos-cloud',
                                              'images',
                                              context.properties[
                                                  'containerImage'])
              },
          }],
      'networkInterfaces': [{
          'accessConfigs': [{
              'name': 'external-nat',
              'type': 'ONE_TO_ONE_NAT'
              }],
          'network': GlobalComputeUrl(context.env['project'],
                                      'networks',
                                      'default')
          }],
        'serviceAccounts': [{
            'email': 'default',
            'scopes': ['https://www.googleapis.com/auth/logging.write']
            }]
      }

  # Resources to return.
  resources = {
      'resources': [{
          'name': base_name,
          'type': 'compute.v1.instance',
          'properties': instance
          }]
      }

  return resources

La plantilla define una serie de variables, como containerImage y manifest, que se rellenarán cuando defina la configuración. Esta plantilla solo crea una instancia de máquina virtual.

Cuando usas imágenes de contenedor en instancias de Compute Engine, también debes proporcionar un archivo de manifiesto (distinto de un manifiesto de Deployment Manager) para describir a Compute Engine qué imagen de contenedor debe usar. Crea un método auxiliar llamado container_helper.[py|jinja] para definir dinámicamente el manifiesto del contenedor:

Jinja 



{% macro GenerateManifest(name, port, dockerImage, dockerEnv) -%}

apiVersion: v1
kind: Pod
metadata:
  name: {{ name }}
spec:
  containers:
  - name: {{ name }}
    image: {{ dockerImage }}
    ports:
    - hostPort: {{ port }}
      containerPort: {{ port }}
    {% if dockerEnv -%}
    env:
    {% for key, value in dockerEnv.items() -%}
    - name: {{ key }}
      value: '{{ value }}'
    {% endfor -%}
    {% endif -%}
{%- endmacro -%}

Python 

# 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.

"""Helper methods for working with containers in config."""

import six
import yaml


def GenerateManifest(context):
  """Generates a Container Manifest given a Template context.

  Args:
    context: Template context, which must contain dockerImage and port
        properties, and an optional dockerEnv property.

  Returns:
    A Container Manifest as a YAML string.
  """
  env_list = []
  if 'dockerEnv' in context.properties:
    for key, value in six.iteritems(context.properties['dockerEnv']):
      env_list.append({'name': key, 'value': str(value)})

  manifest = {
      'apiVersion': 'v1',
      'kind': 'Pod',
      'metadata': {
          'name': str(context.env['name'])
          },
      'spec': {
          'containers': [{
              'name': str(context.env['name']),
              'image': context.properties['dockerImage'],
              'ports': [{
                  'hostPort': context.properties['port'],
                  'containerPort': context.properties['port']
                  }],
              }]
          }
      }

  if env_list:
    manifest['spec']['containers'][0]['env'] = env_list

  return yaml.dump(manifest, default_flow_style=False)

Crear las plantillas de frontend

El frontend de esta aplicación ejecuta Node.js y permite a los usuarios publicar mensajes en la página web. Habrá dos grupos de instancias gestionados que contengan dos instancias cada uno: un grupo de instancias gestionado principal y un grupo de instancias gestionado secundario para el balanceo de carga.

Para crear estas plantillas de frontend, siga estas instrucciones.

  1. Crea una plantilla de instancia.

    Necesitas un recurso de plantilla de instancia para crear un grupo de instancias gestionado, que es un grupo de instancias de VM idénticas que se gestionan de forma centralizada. En este ejemplo se crea un grupo de instancias gestionado para las instancias de frontend de Node.js, pero primero debes crear la plantilla de instancia.

    Define un archivo llamado container_instance_template.[py|jinja]:

    Jinja 

    

{% from 'container_helper.jinja' import GenerateManifest %}
{% set IT_NAME = env['name'] + '-it' %}

resources:
- name: {{ IT_NAME }}
  type: compute.v1.instanceTemplate
  properties:
    properties:
      metadata:
        items:
        - key: gce-container-declaration
          value: |
            {{ GenerateManifest(env['name'], properties['port'],properties['dockerImage'], properties['dockerEnv'])|indent(12) }}
      machineType: f1-micro
      disks:
      - deviceName: boot
        boot: true
        autoDelete: true
        mode: READ_WRITE
        type: PERSISTENT
        initializeParams:
          sourceImage: https://www.googleapis.com/compute/v1/projects/cos-cloud/global/images/{{ properties['containerImage'] }}
      networkInterfaces:
      - accessConfigs:
        - name: external-nat
          type: ONE_TO_ONE_NAT
        network: https://www.googleapis.com/compute/v1/projects/{{ env['project'] }}/global/networks/default
      serviceAccounts:
        - email: default
          scopes:
          - https://www.googleapis.com/auth/logging.write
          - https://www.googleapis.com/auth/monitoring.write
outputs:
- name: instanceTemplateSelfLink
  value: $(ref.{{ IT_NAME }}.selfLink)

    Python 

    # 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.

"""Creates a Container VM with the provided Container manifest."""

from container_helper import GenerateManifest


def GenerateConfig(context):
  """Generates configuration."""

  image = ''.join(['https://www.googleapis.com/compute/v1/',
                   'projects/cos-cloud/global/images/',
                   context.properties['containerImage']])
  default_network = ''.join(['https://www.googleapis.com/compute/v1/projects/',
                             context.env['project'],
                             '/global/networks/default'])

  instance_template = {
      'name': context.env['name'] + '-it',
      'type': 'compute.v1.instanceTemplate',
      'properties': {
          'properties': {
              'metadata': {
                  'items': [{
                      'key': 'gce-container-declaration',
                      'value': GenerateManifest(context)
                      }]
                  },
              'machineType': 'f1-micro',
              'disks': [{
                  'deviceName': 'boot',
                  'boot': True,
                  'autoDelete': True,
                  'mode': 'READ_WRITE',
                  'type': 'PERSISTENT',
                  'initializeParams': {'sourceImage': image}
                  }],
              'networkInterfaces': [{
                  'accessConfigs': [{
                      'name': 'external-nat',
                      'type': 'ONE_TO_ONE_NAT'
                      }],
                  'network': default_network
                  }],
                'serviceAccounts': [{
                    'email': 'default',
                    'scopes': ['https://www.googleapis.com/auth/logging.write']
                    }]
              }
          }
      }

  outputs = [{'name': 'instanceTemplateSelfLink',
              'value': '$(ref.' + instance_template['name'] + '.selfLink)'}]

  return {'resources': [instance_template], 'outputs': outputs}

  2. Crea un grupo de instancias gestionado con escalado automático.

    Ahora que tienes una plantilla de instancia, puedes definir una plantilla que la use para crear un grupo de instancias gestionado con escalado automático. Crea un archivo llamado autoscaled_group.[py|jinja] con el siguiente contenido:

    Jinja 

    

resources:
  - name: {{ env["name"] }}-igm
    type: compute.v1.instanceGroupManager
    properties:
      zone: {{ properties["zone"] }}
      targetSize: {{ properties["size"] }}
      baseInstanceName: {{ env["name"] }}-instance
      instanceTemplate: {{ properties["instanceTemplate"] }}

  - name: {{ env["name"] }}-as
    type: compute.v1.autoscaler
    properties:
      zone: {{ properties["zone"] }}
      target: $(ref.{{ env["name"] }}-igm.selfLink)
      autoscalingPolicy:
        maxNumReplicas: {{ properties["maxSize"] }}

    Python 

    # 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.

"""Creates autoscaled, network LB IGM running specified docker image."""


def GenerateConfig(context):
  """Generate YAML resource configuration."""

  # NOTE: Once we can specify the port/service during creation of IGM,
  # we will wire it up here.
  name = context.env['name']
  resources = [{
      'name': name + '-igm',
      'type': 'compute.v1.instanceGroupManager',
      'properties': {
          'zone': context.properties['zone'],
          'targetSize': context.properties['size'],
          'baseInstanceName': name + '-instance',
          'instanceTemplate': context.properties['instanceTemplate']
      }
  }, {
      'name': name + '-as',
      'type': 'compute.v1.autoscaler',
      'properties': {
          'zone': context.properties['zone'],
          'target': '$(ref.' + name + '-igm.selfLink)',
          'autoscalingPolicy': {
              'maxNumReplicas': context.properties['maxSize']

          }
      }
  }]
  return {'resources': resources}

    Crea el archivo de esquema correspondiente:

    Jinja 

    # 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.

info:
  title: Autoscaled, network LB IGM template
  author: Google
  description: Creates an autoscaled Instance Group Manager running the specified Docker image
  version: 1.0

required:
- zone
- instanceTemplate

properties:
  zone:
    type: string
    description: Zone in which this VM will run

  instanceTemplate:
    type: string
    description: URL for the instance template to use for IGM

  size:
    type: integer
    default: 1
    description: Initial size of the Managed Instance Group

  maxSize:
    type: integer
    default: 1
    description: Maximum size the Managed Instance Group will be autoscaled to

    Python 

    # 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.

info:
  title: Autoscaled, network LB IGM template
  author: Google
  description: Creates an autoscaled Instance Group Manager running the specified Docker image
  version: 1.0

required:
- zone
- instanceTemplate

properties:
  zone:
    type: string
    description: Zone in which this VM will run

  instanceTemplate:
    type: string
    description: URL for the instance template to use for IGM

  size:
    type: integer
    default: 1
    description: Initial size of the Managed Instance Group

  maxSize:
    type: integer
    default: 1
    description: Maximum size the Managed Instance Group will be autoscaled to

  3. Crea recursos con estas plantillas.

    Hasta ahora, has definido plantillas base que determinan las propiedades de tus recursos. Con estas plantillas, define la configuración de tu frontend. Crea un archivo llamado service.[py|jinja] con el siguiente contenido:

    Jinja 

    

resources:
  - name: {{ env["name"] }}
    type: container_instance_template.jinja
    properties:
      port: {{ properties["port"] }}
      dockerEnv: {{ properties["dockerEnv"] }}
      dockerImage: {{ properties["dockerImage"] }}
      containerImage: {{ properties["containerImage"] }}

  - name: {{ env["name"] }}-pri
    type: autoscaled_group.jinja
    properties:
      zone: {{ properties["primaryZone"] }}
      size: {{ properties["primarySize"] }}
      maxSize: {{ properties["maxSize"] }}
      port: {{ properties["port"] }}
      service: {{ properties["service"] }}
      baseInstanceName: {{ env["name"] }}-instance
      instanceTemplate: $(ref.{{ env["name"] }}-it.selfLink)

  - name: {{ env["name"] }}-sec
    type: autoscaled_group.jinja
    properties:
      zone: {{ properties["secondaryZone"] }}
      size: {{ properties["secondarySize"] }}
      maxSize: {{ properties["maxSize"] }}
      port: {{ properties["port"] }}
      service: {{ properties["service"] }}
      baseInstanceName: {{ env["name"] }}-instance
      instanceTemplate: $(ref.{{ env["name"] }}-it.selfLink)

  - name: {{ env["name"] }}-hc
    type: compute.v1.httpHealthCheck
    properties:
      port: {{ properties["port"] }}
      requestPath: /_ah/health

  - name: {{ env["name"] }}-bes
    type: compute.v1.backendService
    properties:
      port: {{ properties["port"] }}
      portName: {{ properties["service"] }}
      backends:
        - name: {{ env["name"] }}-primary
          group: $(ref.{{ env["name"] }}-pri-igm.instanceGroup)
        - name: {{ env["name"] }}-secondary
          group: $(ref.{{ env["name"] }}-sec-igm.instanceGroup)
      healthChecks: [ $(ref.{{ env["name"] }}-hc.selfLink) ]

    Python 

    # 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.

"""Creates primary/secondary zone autoscaled IGM running specified container."""


def GenerateConfig(context):
  """Generate YAML resource configuration."""

  name = context.env['name']

  resources = [{
      'name': name,
      'type': 'container_instance_template.py',
      'properties': {
          'port': context.properties['port'],
          'dockerEnv': context.properties['dockerEnv'],
          'dockerImage': context.properties['dockerImage'],
          'containerImage': context.properties['containerImage']
      }
  }, {
      'name': name + '-pri',
      'type': 'autoscaled_group.py',
      'properties': {
          'zone': context.properties['primaryZone'],
          'size': context.properties['primarySize'],
          'maxSize': context.properties['maxSize'],
          'port': context.properties['port'],
          'service': context.properties['service'],
          'baseInstanceName': name + '-instance',
          'instanceTemplate': '$(ref.' + name + '-it.selfLink)'
      }
  }, {
      'name': name + '-sec',
      'type': 'autoscaled_group.py',
      'properties': {
          'zone': context.properties['secondaryZone'],
          'size': context.properties['secondarySize'],
          'maxSize': context.properties['maxSize'],
          'port': context.properties['port'],
          'service': context.properties['service'],
          'baseInstanceName': name + '-instance',
          'instanceTemplate': '$(ref.' + name + '-it.selfLink)'
      }
  }, {
      'name': name + '-hc',
      'type': 'compute.v1.httpHealthCheck',
      'properties': {
          'port': context.properties['port'],
          'requestPath': '/_ah/health'
      }
  }, {
      'name': name + '-bes',
      'type': 'compute.v1.backendService',
      'properties': {
          'port': context.properties['port'],
          'portName': context.properties['service'],
          'backends': [{
              'name': name + '-primary',
              'group': '$(ref.' + name + '-pri-igm.instanceGroup)'
          }, {
              'name': name + '-secondary',
              'group': '$(ref.' + name + '-sec-igm.instanceGroup)'
          }],
          'healthChecks': ['$(ref.' + name + '-hc.selfLink)']
      }
  }]
  return {'resources': resources}

    Crea el archivo de esquema correspondiente:

    Jinja 

    # 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.

info:
  title: Autoscaled IGM
  author: Google
  description: Creates primary/secondary zone autoscaled IGM running specified container.
  version: 1.0

imports:
- path: autoscaled_group.jinja
- path: ../../common/jinja/container_instance_template.jinja
  name: container_instance_template.jinja

required:
- port
- service
- primaryZone
- secondaryZone
- dockerImage

properties:
  primarySize:
    type: integer
    default: 1
    description: The size of the primary autoscaled IGM

  secondarySize:
    type: integer
    default: 0
    description: The size of the secondary autoscaled IGM

  maxSize:
    type: integer
    default: 1
    description: The maximum size of the IGM

  containerImage:
    type: string
    default: family/cos-stable
    description: The container image to be used

  dockerEnv:
    type: object
    default: {}
    description: The container environment variables

  dockerImage:
    type: string
    description: the docker image to be used

  port:
    type: integer
    description: Port to expose on the container as well as on the load balancer (e.g., 8080)

  service:
    type: string
    description: Name of the service the port exposes for loadbalancing (backendService) purposes

  primaryZone:
    type: string
    description: Primary Zone in which to run the service

  secondaryZone:
    type: string
    description: Secondary Zone in which to run the service

    Python 

    # 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.

info:
  title: Autoscaled IGM
  author: Google
  description: Creates primary/secondary zone autoscaled IGM running specified container.
  version: 1.0

imports:
- path: autoscaled_group.py
- path: ../../common/python/container_instance_template.py
  name: container_instance_template.py

required:
- port
- service
- primaryZone
- secondaryZone
- dockerImage

properties:
  primarySize:
    type: integer
    default: 1
    description: The size of the primary autoscaled IGM

  secondarySize:
    type: integer
    default: 0
    description: The size of the secondary autoscaled IGM

  maxSize:
    type: integer
    default: 1
    description: The maximum size of the IGM

  containerImage:
    type: string
    default: family/cos-stable
    description: The container image to be used

  dockerEnv:
    type: object
    default: {}
    description: The container environment variables

  dockerImage:
    type: string
    description: the docker image to be used

  port:
    type: integer
    description: Port to expose on the container as well as on the load balancer (e.g., 8080)

  service:
    type: string
    description: Name of the service the port exposes for loadbalancing (backendService) purposes

  primaryZone:
    type: string
    description: Primary Zone in which to run the service

  secondaryZone:
    type: string
    description: Secondary Zone in which to run the service

    Vamos a desglosar lo que crea esta plantilla:

    1. Dos grupos de instancias gestionados, uno principal y otro secundario.

      La plantilla usa la plantilla autoscaled_group.[py|jinja] para crear un grupo de instancias gestionado con autoescalado principal y otro secundario.

    2. A continuación, la plantilla crea un servicio de backend y un comprobador de estado. Se necesita un servicio de backend para el balanceo de carga HTTP, que define la capacidad de servicio de los grupos de instancias de ese servicio de backend. En este caso, los grupos de instancias gestionados primario y secundario forman parte de este backend, y se aplican las propiedades predeterminadas del servicio de backend.

      De forma predeterminada, un servicio de backend realiza el balanceo de carga en función del uso de CPU de los grupos de instancias asociados, pero también puedes balancear la carga en función de las solicitudes por segundo (RPS).

      Nota: Siempre se requiere una comprobación del estado al crear un servicio de backend.

Crear una plantilla unificadora

Por último, crea una plantilla unificada que combine las plantillas de backend y de frontend. Crea un archivo llamado application.[py|jinja]:

Jinja 



{% set BACKEND = env["deployment"] + "-backend" %}
{% set FRONTEND = env["deployment"] + "-frontend" %}
{% set STATIC_SERVICE = env["deployment"] + "-static-service" %}
{% set APPLICATION = env["deployment"] + "-application" %}

{% set APPLICATION_PORT = 8080 %}
{% set LB_PORT = 8080 %}
{% set MYSQL_PORT = 8080 %}

{% set CONTAINER_IMAGE = "family/cos-stable" %}

resources:
- name: {{ BACKEND }}
  type: container_vm.jinja
  properties:
    zone: {{ properties["primaryZone"] }}
    dockerImage: {{ properties["backendImage"] }}
    containerImage: {{ CONTAINER_IMAGE }}
    port: {{ MYSQL_PORT }}

- name: {{ FRONTEND }}
  type: service.jinja
  properties:
    primaryZone: {{ properties["primaryZone"] }}
    primarySize: 2
    secondaryZone: {{ properties["secondaryZone"] }}
    secondarySize: 0
    dockerImage: {{ properties["frontendImage"] }}
    containerImage: {{ CONTAINER_IMAGE }}
    port: {{ APPLICATION_PORT }}
    service: http
    # If left out will default to 1
    maxSize: 20

    # Define the variables that are exposed to container as env variables.
    dockerEnv:
      SEVEN_SERVICE_MYSQL_PORT: {{ MYSQL_PORT }}
      SEVEN_SERVICE_PROXY_HOST: $(ref.{{ BACKEND }}.networkInterfaces[0].networkIP)

- name: {{ STATIC_SERVICE }}
  type: service.jinja
  properties:
    primaryZone: {{ properties["primaryZone"] }}
    primarySize: 2
    secondaryZone: {{ properties["secondaryZone"] }}
    secondarySize: 0
    dockerImage: {{ properties["staticImage"] }}
    containerImage: {{ CONTAINER_IMAGE }}
    port: {{ APPLICATION_PORT }}
    service: httpstatic
    # If left out will default to 1
    maxSize: 20

- name: {{ APPLICATION }}-urlmap
  type: compute.v1.urlMap
  properties:
    defaultService: $(ref.{{ FRONTEND }}-bes.selfLink)
    hostRules:
      - hosts: ["*"]
        pathMatcher: pathmap
    pathMatchers:
      - name: pathmap
        defaultService: $(ref.{{ FRONTEND }}-bes.selfLink)
        pathRules:
          - paths: ["/static", "/static/*"]
            service: $(ref.{{ STATIC_SERVICE }}-bes.selfLink)
- name: {{ APPLICATION }}-targetproxy
  type: compute.v1.targetHttpProxy
  properties:
    urlMap: $(ref.{{ APPLICATION }}-urlmap.selfLink)
- name: {{ APPLICATION }}-l7lb
  type: compute.v1.globalForwardingRule
  properties:
    IPProtocol: TCP
    portRange: {{ LB_PORT }}
    target: $(ref.{{ APPLICATION }}-targetproxy.selfLink)
- name: {{ APPLICATION }}-fw
  type: compute.v1.firewall
  properties:
    allowed:
      - IPProtocol: TCP
        ports: [ {{ LB_PORT }} ]
    sourceRanges: [ 0.0.0.0/0 ]

Python 


# 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.

"""Create appplication template with back-end and front-end templates."""


def GenerateConfig(context):
  """Generate configuration."""

  backend = context.env['deployment'] + '-backend'
  frontend = context.env['deployment'] + '-frontend'
  static_service = context.env['deployment'] + '-static-service'
  application = context.env['deployment'] + '-application'

  container_image = 'family/cos-stable'

  application_port = 8080
  lb_port = 8080
  mysql_port = 8080

  resources = [{
      'name': backend,
      'type': 'container_vm.py',
      'properties': {
          'zone': context.properties['primaryZone'],
          'dockerImage': context.properties['backendImage'],
          'containerImage': container_image,
          'port': mysql_port
      }
  }, {
      'name': frontend,
      'type': 'service.py',
      'properties': {
          'primaryZone': context.properties['primaryZone'],
          'primarySize': 2,
          'secondaryZone': context.properties['secondaryZone'],
          'secondarySize': 0,
          'dockerImage': context.properties['frontendImage'],
          'containerImage': container_image,
          'port': application_port,
          'service': 'http',
          # If left out will default to 1
          'maxSize': 20,
          # Define the variables that are exposed to container as env variables.
          'dockerEnv': {
              'SEVEN_SERVICE_MYSQL_PORT': mysql_port,
              'SEVEN_SERVICE_PROXY_HOST': '$(ref.' + backend
                                          + '.networkInterfaces[0].networkIP)'
          }
      }
  }, {
      'name': static_service,
      'type': 'service.py',
      'properties': {
          'primaryZone': context.properties['primaryZone'],
          'primarySize': 2,
          'secondaryZone': context.properties['secondaryZone'],
          'secondarySize': 0,
          'dockerImage': context.properties['staticImage'],
          'containerImage': container_image,
          'port': application_port,
          'service': 'httpstatic',
          # If left out will default to 1
          'maxSize': 20
      }
  }, {
      'name': application + '-urlmap',
      'type': 'compute.v1.urlMap',
      'properties': {
          'defaultService': '$(ref.' + frontend + '-bes.selfLink)',
          'hostRules': [{
              'hosts': ['*'],
              'pathMatcher': 'pathmap'
          }],
          'pathMatchers': [{
              'name': 'pathmap',
              'defaultService': '$(ref.' + frontend + '-bes.selfLink)',
              'pathRules': [{
                  'paths': ['/static', '/static/*'],
                  'service': '$(ref.' + static_service + '-bes.selfLink)'
              }]
          }]
      }
  }, {
      'name': application + '-targetproxy',
      'type': 'compute.v1.targetHttpProxy',
      'properties': {
          'urlMap': '$(ref.' + application + '-urlmap.selfLink)'
      }
  }, {
      'name': application + '-l7lb',
      'type': 'compute.v1.globalForwardingRule',
      'properties': {
          'IPProtocol': 'TCP',
          'portRange': lb_port,
          'target': '$(ref.' + application + '-targetproxy.selfLink)'
      }
  }, {
      'name': application + '-fw',
      'type': 'compute.v1.firewall',
      'properties': {
          'allowed': [{
              'IPProtocol': 'TCP',
              'ports': [lb_port]
          }],
          'sourceRanges': ['0.0.0.0/0']
      }
  }]
  return {'resources': resources}

Crea un archivo de esquema correspondiente:

Jinja 

# 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.

info:
  title: Application Template
  author: Google
  description: Create application template with back-end and front-end templates
  version: 1.0

imports:
- path: service.jinja
- path: ../../common/jinja/container_vm.jinja
  name: container_vm.jinja

required:
- primaryZone
- secondaryZone
- backendImage
- frontendImage
- staticImage

properties:
  primaryZone:
    type: string
    description: Primary Zone in which to run the service

  secondaryZone:
    type: string
    description: Secondary Zone in which to run the service

  backendImage:
    type: string
    description: Docker image to use in the backend

  frontendImage:
    type: string
    description: Docker image to use in the frontend service

  staticImage:
    type: string
    description: Docker image to use in the static service

Python 

# 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.

info:
  title: Application Template
  author: Google
  description: Create application template with back-end and front-end templates
  version: 1.0

imports:
- path: service.py
- path: ../../common/python/container_vm.py
  name: container_vm.py

required:
- primaryZone
- secondaryZone
- backendImage
- frontendImage
- staticImage

properties:
  primaryZone:
    type: string
    description: Primary Zone in which to run the service

  secondaryZone:
    type: string
    description: Secondary Zone in which to run the service

  backendImage:
    type: string
    description: Docker image to use in the backend

  frontendImage:
    type: string
    description: Docker image to use in the frontend service

  staticImage:
    type: string
    description: Docker image to use in the static service

Además del frontend y el backend, la plantilla también define algunos recursos adicionales:

  1. Un servicio estático con grupos de instancias gestionadas principales y secundarios. Este servicio estático sirve una página web ubicada en la ruta /static de tu aplicación.

  2. Recurso URLMap. El balanceo de carga HTTP requiere un mapa de URLs para asignar las diferentes URLs a las rutas correctas. En este caso, la ruta predeterminada, indicada por la propiedad defaultService, es el servicio de backend que has creado anteriormente. Si un usuario accede a /static, el mapa de URLs asignará esa ruta al servicio estático, tal como se define en la sección pathMatchers.

  3. Una regla de reenvío global y un proxy HTTP de destino. Como la carga de la aplicación se equilibra entre dos zonas independientes, necesitarás una regla de reenvío global que sirva una única dirección IP externa. Además, se necesita un proxy HTTP de destino para configurar el balanceo de carga HTTP.

  4. Una regla de cortafuegos que permite el tráfico a través del puerto 8080.

Crear una configuración

Ahora que tienes listas tus plantillas y los esquemas relacionados, puedes crear una configuración que despliegue estos recursos. Crea un archivo de configuración llamado application.yaml con el siguiente contenido y sustituye ZONE_TO_RUN y SECONDARY_ZONE_TO_RUN por las zonas principal y secundaria que elijas.

Jinja 

# 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.

# Launches an autoscaled, load-balanced frontend in two zones running nodejs
# for serving traffic using L7 loadbalancing. Also launches a single MySQL
# container instance, wires the two together using references, and passes
# them as env variables to the underlying frontend Docker containers.
#
# NOTE: Due to the fact that IGM does not allow specifying service/port to
# created IG, you must run the following commands after creation of the
# template:
#
# export DEPLOYMENT=<DEPLOYMENT NAME>
# export PRIMARY_ZONE=<PRIMARY ZONE>
# export SECONDARY_ZONE=<SECONDARY ZONE>
#
# gcloud compute instance-groups unmanaged set-named-ports ${DEPLOYMENT}-frontend-pri-igm \
#  --named-ports http:8080,httpstatic:8080 \
#  --zone ${PRIMARY_ZONE}
#
# gcloud compute instance-groups unmanaged set-named-ports ${DEPLOYMENT}-frontend-sec-igm \
#  --named-ports http:8080,httpstatic:8080 \
#  --zone ${SECONDARY_ZONE}
#
# Then to see the IP that exposes the application, you can do:
# gcloud compute forwarding-rules list | grep application-${DEPLOYMENT}-l7lb

imports:
- path: application.jinja

resources:
- name: nodejs
  type: application.jinja
  properties:
    primaryZone: ZONE_TO_RUN
    secondaryZone: SECOND_ZONE_TO_RUN
    backendImage: gcr.io/deployment-manager-examples/mysql
    frontendImage: gcr.io/deployment-manager-examples/nodejsservice
    staticImage: gcr.io/deployment-manager-examples/nodejsservicestatic

Python 

# 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.

# Launches an autoscaled, load-balanced frontend in two zones running nodejs
# for serving traffic using L7 loadbalancing. Also launches a single MySQL
# container instance, wires the two together using references, and passes
# them as env variables to the underlying frontend Docker containers.
#
# NOTE: Due to the fact that IGM does not allow specifying service/port to
# created IG, you must run the following commands after creation of the
# template:
#
# export DEPLOYMENT=<DEPLOYMENT NAME>
# export PRIMARY_ZONE=<PRIMARY ZONE>
# export SECONDARY_ZONE=<SECONDARY ZONE>
#
# gcloud compute instance-groups unmanaged set-named-ports ${DEPLOYMENT}-frontend-pri-igm \
#  --named-ports http:8080,httpstatic:8080 \
#  --zone ${PRIMARY_ZONE}
#
# gcloud compute instance-groups unmanaged set-named-ports ${DEPLOYMENT}-frontend-sec-igm \
#  --named-ports http:8080,httpstatic:8080 \
#  --zone ${SECONDARY_ZONE}
#
# Then to see the IP that exposes the application, you can do:
# gcloud compute forwarding-rules list | grep application-${DEPLOYMENT}-l7lb

imports:
- path: application.py

resources:
- name: nodejs
  type: application.py
  properties:
    primaryZone: ZONE_TO_RUN
    secondaryZone: SECOND_ZONE_TO_RUN
    backendImage: gcr.io/deployment-manager-examples/mysql
    frontendImage: gcr.io/deployment-manager-examples/nodejsservice
    staticImage: gcr.io/deployment-manager-examples/nodejsservicestatic

Desplegar la configuración

Ahora, vamos a desplegar tus recursos. Con la CLI de Google Cloud, ejecuta el siguiente comando. También puedes sustituir advanced-configuration-l7 por el nombre de implementación que quieras. Ten en cuenta que el nombre del despliegue se usará automáticamente para nombrar los recursos.

En este ejemplo, el nombre de la implementación es advanced-configuration-l7. Si decides cambiar el nombre de la implementación, asegúrate de usarlo en todos los ejemplos siguientes.

gcloud deployment-manager deployments create advanced-configuration-l7 --config application.yaml

La respuesta debería ser similar a la de los siguientes recursos:

Waiting for create operation-1469468950934-5387966d431f0-49b11bc4-1421b2f0...done.
Create operation operation-1469468950934-5387966d431f0-49b11bc4-1421b2f0 completed successfully.
NAME                                               TYPE                             STATE      ERRORS
advanced-configuration-l7-application-fw           compute.v1.firewall              COMPLETED  []
advanced-configuration-l7-application-l7lb         compute.v1.globalForwardingRule  COMPLETED  []
advanced-configuration-l7-application-targetproxy  compute.v1.targetHttpProxy       COMPLETED  []
advanced-configuration-l7-application-urlmap       compute.v1.urlMap                COMPLETED  []
advanced-configuration-l7-backend                  compute.v1.instance              COMPLETED  []
advanced-configuration-l7-frontend-bes             compute.v1.backendService        COMPLETED  []
advanced-configuration-l7-frontend-hc              compute.v1.httpHealthCheck       COMPLETED  []
advanced-configuration-l7-frontend-it              compute.v1.instanceTemplate      COMPLETED  []
advanced-configuration-l7-frontend-pri-as          compute.v1.autoscaler            COMPLETED  []
advanced-configuration-l7-frontend-pri-igm         compute.v1.instanceGroupManager  COMPLETED  []
advanced-configuration-l7-frontend-sec-as          compute.v1.autoscaler            COMPLETED  []
advanced-configuration-l7-frontend-sec-igm         compute.v1.instanceGroupManager  COMPLETED  []
advanced-configuration-l7-static-service-bes       compute.v1.backendService        COMPLETED  []
advanced-configuration-l7-static-service-hc        compute.v1.httpHealthCheck       COMPLETED  []
advanced-configuration-l7-static-service-it        compute.v1.instanceTemplate      COMPLETED  []
advanced-configuration-l7-static-service-pri-as    compute.v1.autoscaler            COMPLETED  []
advanced-configuration-l7-static-service-pri-igm   compute.v1.instanceGroupManager  COMPLETED  []
advanced-configuration-l7-static-service-sec-as    compute.v1.autoscaler            COMPLETED  []
advanced-configuration-l7-static-service-sec-igm   compute.v1.instanceGroupManager  COMPLETED  []

Añadir etiquetas de servicio

A continuación, especifica las etiquetas de servicio adecuadas para tus grupos de instancias gestionadas. Las etiquetas de servicio son metadatos que utiliza el servicio de balanceo de carga para agrupar recursos.

Para añadir etiquetas de servicio, ejecuta los siguientes comandos, que coincidan con las zonas primarias y secundarias que hayas seleccionado en el archivo de configuración de la implementación:

gcloud compute instance-groups unmanaged set-named-ports advanced-configuration-l7-frontend-pri-igm \
  --named-ports http:8080,httpstatic:8080 \
  --zone [PRIMARY_ZONE]

gcloud compute instance-groups unmanaged set-named-ports advanced-configuration-l7-frontend-sec-igm \
  --named-ports http:8080,httpstatic:8080 \
  --zone [SECONDARY_ZONE]

Probar la configuración

Para probar la configuración, obtén la dirección IP externa que está sirviendo el tráfico consultando la regla de reenvío:

gcloud compute forwarding-rules list | grep advanced-configuration-l7-l7lb
advanced-configuration-l7-l7lb             107.178.249.126 TCP         advanced-configuration-l7-targetproxy

En este caso, la IP externa es 107.178.249.126.

En un navegador, visita la dirección IP externa en el puerto 8080. Por ejemplo, si tu IP externa es 107.178.249.126, la URL sería la siguiente:

http://107.178.249.126:8080

Debería mostrarse una página en blanco, que es lo esperado. A continuación, publica un mensaje en la página. Ve a la URL siguiente:

http://107.178.249.126:8080?msg=hello_world!

Verás una confirmación de que se ha añadido tu mensaje. Vuelve a la URL principal. Ahora, la página debería mostrar el siguiente mensaje:

hello_world!

También puedes visitar la página estática que has creado o comprobar el estado de tu aplicación en las siguientes URLs:

# Static web page
http://107.178.249.126:8080/static

# Health check
http://107.178.249.126:8080/_ah/health

Enhorabuena, has implementado tu configuración correctamente.

(Opcional) Crear imágenes de Docker

Docker te permite automatizar y ejecutar software en contenedores. Los contenedores te permiten aislar diferentes servicios en contenedores que pueden ejecutarse en una sola instancia de Linux.

En este ejemplo se han usado algunas imágenes Docker, pero también puedes crear tus propias versiones de estas imágenes. Puedes consultar las instrucciones para crear las imágenes de backend de MySQL y las imágenes de frontend de Node.js en la sección Crear plantillas de recursos.

Para crear la imagen Docker que sirve la página web estática, sigue estos pasos:

  1. Crea una instancia de VM con una imagen optimizada para contenedores:

    gcloud compute instances create docker-playground \
  --image-family container-vm \
  --image-project google-containers \
  --zone us-central1-a \
  --machine-type f1-micro

  2. Conéctate a la instancia:

    gcloud compute ssh --zone us-central1-a docker-playground

  3. Crea un archivo llamado Dockerfile con el siguiente contenido:

    FROM node:latest

RUN mkdir /var/www/
ADD service.js /var/www/service.js
WORKDIR /var/www/
RUN npm install mysql

CMD ["node", "service.js"]

  4. Crea un archivo llamado service.js con el siguiente contenido:

    var http = require('http');
var url = require('url');

console.log('Started static node server')

http.createServer(function (req, res) {
  reqUrl = url.parse(req.url, true);

  res.useChunkedEncodingByDefault = false;
  res.writeHead(200, {'Content-Type': 'text/html'});

  if (reqUrl.pathname == '/_ah/health') {
    res.end('ok');
  } else if (reqUrl.pathname == '/exit') {
    process.exit(-1)
  } else {
      res.end('static server');
  }
}).listen(8080, '0.0.0.0');

console.log('Static server running at http://127.0.0.1:8080/');

  5. Compila la imagen Docker y sustituye username por tu nombre de usuario de Docker Hub. Si no tienes un nombre de usuario de Docker Hub, crea uno antes de compilar la imagen Docker.

    sudo docker build --no-cache -t username/nodejsservicestatic .

  6. Envía las imágenes al repositorio de Docker:

    sudo docker push username/nodejsservicestatic

Ahora tienes las imágenes de Docker para ejecutar Node.js y MySQL. Puedes ver estas imágenes en el repositorio buscando los nombres de las imágenes. Para probar las imágenes, puedes sustituir todas las instancias de gcr.io/deployment-manager-examples/mysql y gcr.io/deployment-manager-examples/nodejsservice por las imágenes correspondientes.

Pasos siguientes

Una vez que haya completado esta muestra, podrá hacer lo siguiente:

  • Sigue desarrollando este ejemplo creando una página web más sólida o añadiendo más servicios al servidor web.
  • Consulta más información sobre las configuraciones o las implementaciones.
  • Prueba a crear tus propias configuraciones.