Implementa una app de libro de registro con balanceo de cargas de red

En este instructivo, implementarás una app de libro de registro de ejemplo que usa Node.js para su frontend y MySQL para su backend. Al final del instructivo, la implementación tiene los siguientes recursos:

Si eres nuevo en Deployment Manager, consulta la Guía de inicio rápido o los instructivos de la Guía paso a paso.

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.
• Lee una descripción general del balanceo de cargas de red de Compute Engine.
• Lee una descripción general de los contenedores de Docker.

Crea plantillas de recursos

En este ejemplo, se inicia una implementación que contiene una variedad de recursos de Google Cloud. Para comenzar, crea plantillas que definan estos recursos por separado. Luego, llamas a estas plantillas en la configuración final. La implementación contiene estos recursos:

• Una instancia de Compute Engine que aloja una base de datos de MySQL para la aplicación.
• Una plantilla de instancias para las instancias de frontend, que utiliza una imagen de Docker para la aplicación de Node.js.
• Un grupo de instancias administrado, que utiliza la plantilla de instancias para crear dos instancias de frontend.
• Un escalador automático, que inicia o detiene instancias de frontend según el tráfico entrante.
• Una verificación de estado, que verifica si las instancias de frontend están disponibles para funcionar.
• Un balanceador de cargas de red con una regla de reenvío.
• Un grupo de destino para el grupo de instancias administrado.

Crea la plantilla para el backend de MySQL

El backend de esta aplicación es una instancia única de Compute Engine que ejecuta un contenedor MySQL Docker. La plantilla container_vm.py define una instancia de Compute Engine que puede ejecutar contenedores de Docker. Para garantizar que la plantilla siga la estructura correcta y contenga todas las propiedades obligatorias, también necesitas un archivo de esquema.

Copia la plantilla que figura a continuación, o descárgala desde el repositorio de GitHub:

# 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

Descargar el archivo de esquema para la plantilla.

La plantilla tiene propiedades no definidas, como containerImage, que se definen en plantillas posteriores.

Cuando usas imágenes de contenedor en instancias de Compute Engine, también debes proporcionar un archivo de manifiesto que describa cuál imagen de contenedor se debe usar. Crea un método auxiliar llamado container_helper.py para definir de forma dinámica el manifiesto del contenedor:

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

Crea la plantilla para el frontend de Node.js

El frontend de la app ejecuta Node.js y permite que los usuarios publiquen mensajes en la página web. El frontend se ejecuta en un grupo de instancias de máquinas virtuales, que son compatibles con un escalador automático y un balanceador de cargas. Para crear plantillas de frontend, sigue estas instrucciones.

1. Crea un recurso de plantilla de instancias.

   Necesitas una plantilla de instancias para crear un grupo de instancias administrado, que es un grupo de instancias de máquinas virtuales (VM) idénticas que controlas como una sola entidad.

   Crea un archivo llamado container_instance_template.py y descarga el esquema para la plantilla:

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

   Descargar el archivo de esquema para la plantilla.

2. Crea un escalador automático, un grupo de instancias administrado y un balanceador de cargas.

   A continuación, crea otra plantilla que use la plantilla container_instance_template.py y crea el resto de tus recursos de frontend, incluido un escalador automático, un balanceador de cargas y un grupo de instancias administrado.

Esta plantilla incluye los siguientes recursos:

1. Una plantilla de instancias que usa la plantilla container_instance_template.py.

2. Un grupo de instancias administrado con el uso de una plantilla de instancias, un escalador automático que hace referencia al grupo de instancias administrado. El uso de referencias garantiza que Deployment Manager cree los recursos en un orden específico. En este caso, el grupo de instancias administrado se crea antes de que el escalador automático.

3. Un balanceador de cargas de red que contiene los siguientes recursos:

   • Una regla de reenvío con una dirección IP externa única expuesta a Internet.
   • Un grupo de destino que contenga el grupo de instancias administrado que creaste anteriormente.
   • Una verificación de estado para adjuntar al grupo de destino.

Crea un archivo llamado frontend.py y descarga el esquema para la plantilla:

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

  # Pull the region out of the zone
  region = context.properties['zone'][:context.properties['zone'].rfind('-')]
  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 + '-igm',
      'type': 'compute.v1.instanceGroupManager',
      'properties': {
          'zone': context.properties['zone'],
          'targetSize': context.properties['size'],
          'targetPools': ['$(ref.' + name + '-tp.selfLink)'],
          'baseInstanceName': name + '-instance',
          'instanceTemplate': '$(ref.' + name + '-it.selfLink)'
      }
  }, {
      'name': name + '-as',
      'type': 'compute.v1.autoscaler',
      'properties': {
          'zone': context.properties['zone'],
          'target': '$(ref.' + name + '-igm.selfLink)',
          'autoscalingPolicy': {
              'maxNumReplicas': context.properties['maxSize']
          }
      }
  }, {
      'name': name + '-hc',
      'type': 'compute.v1.httpHealthCheck',
      'properties': {
          'port': context.properties['port'],
          'requestPath': '/_ah/health'
      }
  }, {
      'name': name + '-tp',
      'type': 'compute.v1.targetPool',
      'properties': {
          'region': region,
          'healthChecks': ['$(ref.' + name + '-hc.selfLink)']
      }
  }, {
      'name': name + '-lb',
      'type': 'compute.v1.forwardingRule',
      'properties': {
          'region': region,
          'portRange': context.properties['port'],
          'target': '$(ref.' + name + '-tp.selfLink)'
      }
  }]
  return {'resources': resources}

Descargar el archivo de esquema para la plantilla.

Crea una plantilla unificadora

Por último, crea una plantilla que reúna las plantillas de backend y frontend. Crea un archivo llamado nodejs.py con los siguientes contenidos:

# 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 nodejs template with the back-end and front-end templates."""


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

  backend = context.env['deployment'] + '-backend'
  frontend = context.env['deployment'] + '-frontend'
  firewall = context.env['deployment'] + '-application-fw'
  application_port = 8080
  mysql_port = 3306
  resources = [{
      'name': backend,
      'type': 'container_vm.py',
      'properties': {
          'zone': context.properties['zone'],
          'dockerImage': 'gcr.io/qwiklabs-resources/mysql',
          'containerImage': 'family/cos-stable',
          'port': mysql_port,
          'dockerEnv': {
              'MYSQL_ROOT_PASSWORD': 'mypassword'
          }
      }
  }, {
      'name': frontend,
      'type': 'frontend.py',
      'properties': {
          'zone': context.properties['zone'],
          'dockerImage': 'gcr.io/qwiklabs-resources/nodejsservice',
          'port': application_port,
          # 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)'
          },
          # If left out will default to 1
          'size': 2,
          # If left out will default to 1
          'maxSize': 20
      }
  }, {
      'name': firewall,
      'type': 'compute.v1.firewall',
      'properties': {
          'allowed': [{
              'IPProtocol': 'TCP',
              'ports': [application_port]
          }],
          'sourceRanges': ['0.0.0.0/0']
      }
  }]
  return {'resources': resources}

Descargar el archivo de esquema para la plantilla.

Ten en cuenta que el frontend de la aplicación se denomina env["deployment"]-frontend y el backend también se denomina de manera similar. Cuando implementas la aplicación, Deployment Manager reemplazará env["deployment"] por el nombre de la implementación de forma automática.

Crea tu configuración

Una vez que tengas todas las plantillas listas, puedes crear una configuración que se usará para implementar los recursos. Crea un archivo de configuración llamado nodejs.yaml con el siguiente contenido:

# 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 running nodejs for serving
# traffic. 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.
imports:
- path: nodejs.py

resources:
- name: nodejs
  type: nodejs.py
  properties:
    zone: ZONE_TO_RUN

Reemplaza ZONE_TO_RUN con la zona en la que deseas tus recursos, como us-central1-a.

Implementar recursos

Ahora, implementa los recursos. Con Google Cloud CLI, ejecuta lo siguiente:

gcloud deployment-manager deployments create advanced-configuration --config nodejs.yaml

Cuando se completa la implementación, Deployment Manager muestra un resumen de los recursos creados, que es similar al que se indica a continuación:

Waiting for create operation-1468522101491-5379cf2344539-5961abe8-a500190c...done.
Create operation operation-1468522101491-5379cf2344539-5961abe8-a500190c completed successfully.
NAME                                   TYPE                             STATE      ERRORS
advanced-configuration-application-fw  compute.v1.firewall              COMPLETED  []
advanced-configuration-backend         compute.v1.instance              COMPLETED  []
advanced-configuration-frontend-as     compute.v1.autoscaler            COMPLETED  []
advanced-configuration-frontend-hc     compute.v1.httpHealthCheck       COMPLETED  []
advanced-configuration-frontend-igm    compute.v1.instanceGroupManager  COMPLETED  []
advanced-configuration-frontend-it     compute.v1.instanceTemplate      COMPLETED  []
advanced-configuration-frontend-lb     compute.v1.forwardingRule        COMPLETED  []
advanced-configuration-frontend-tp     compute.v1.targetPool            COMPLETED  []

Prueba la app

A fin de probar la aplicación, primero obtén la dirección IP externa que entrega el tráfico; para ello, consulta la regla de reenvío:

$ gcloud compute forwarding-rules describe advanced-configuration-frontend-lb --region us-central1
IPAddress: 104.154.81.44
IPProtocol: TCP
creationTimestamp: '2016-07-14T11:48:37.228-07:00'
description: ''
id: '9033201246750269546'
kind: compute#forwardingRule
name: advanced-configuration-frontend-lb
portRange: 8080-8080
region: https://www.googleapis.com/compute/v1/projects/myproject/regions/us-central1
selfLink: https://www.googleapis.com/compute/v1/projects/myproject/regions/us-central1/forwardingRules/advanced-configuration-frontend-lb
target: https://www.googleapis.com/compute/v1/projects/myproject/regions/us-central1/targetPools/advanced-configuration-frontend-tp

En este caso, la IP externa es 104.154.81.44.

A continuación, en el navegador, visita la dirección IP externa con el puerto 8080. Por ejemplo, si la dirección IP externa es 104.154.81.44, esta sería la URL:

http://104.154.81.44:8080

Deberías ver una página en blanco. A continuación, publica un mensaje en la página. Ve a la siguiente URL:

http://104.154.81.44:8080?msg=hellothere!

Verás una confirmación de que se agregó tu mensaje. Navega nuevamente a la URL principal. La página debería tener el siguiente mensaje:

hellothere!

Ahora tienes una aplicación implementada que puede registrar los mensajes que se le enviaron.

Próximos pasos

Después de que hayas completado esta muestra, podrás:

• Compilar este ejemplo mediante la implementación de instancias con tus propios contenedores de Docker. Si deseas modificar los contenedores de Docker que se utilizaron en este instructivo, edita los Dockerfile en el repositorio de GitHub.
• Consulta más implementaciones de ejemplo en el repositorio de GitHub en Deployment Manager.
• Obtén más información sobre las plantillas y las implementaciones.