Creazione di un'app Logbook con bilanciamento del carico HTTP

Questo esempio avanzato mostra come creare un'app di logbook che utilizza Node.js per il frontend e MySQL per il backend. Il modello crea e collega anche un bilanciatore del carico HTTP che esegue il bilanciamento del carico su due zone e un adeguamento automatico per scalare automaticamente l'app.

Risorse di deployment con bilanciamento del carico HTTP
Risorse di deployment con bilanciamento del carico HTTP (fai clic per ingrandire)

Questo esempio presuppone che tu abbia dimestichezza con i contenitori Docker e con le risorse Compute Engine, in particolare con il bilanciamento del carico HTTP, la scalabilità automatica, i gruppi di istanze gestite e i modelli di istanze.

Per altri tutorial introduttivi, consulta la Guida introduttiva o la Guida passo passo.

Prima di iniziare

Creare i modelli

Questo esempio avvia un deployment con diversi tipi di risorse. Per iniziare, crea modelli riutilizzabili che definiscono queste risorse separatamente. In un secondo momento, utilizzerai questi modelli nella configurazione finale.

Al termine di questo esempio, avrai un deployment contenente queste risorse:

  • Una singola istanza Compute Engine per la macchina virtuale MySQL di backend.
  • Un modello di istanza che utilizza un'immagine Docker.
  • Due gruppi di istanze gestite con scalabilità automatica in due zone diverse, che eseguono il servizio frontend Node.js.
  • Altri due gruppi di istanze gestite con scalabilità automatica che pubblicano dati statici.
  • Un controllo di integrità e un bilanciatore del carico HTTP per distribuire il traffico tra i rispettivi gruppi di istanze gestite.

Creazione dei modelli di backend

Il backend di questa app è una singola istanza Compute Engine che esegue un container Docker MySQL. Crea un modello che definisce un'istanza Compute Engine che utilizza un'immagine ottimizzata per i contenitori. Assegna il nome container_vm.[py|jinja] al file:

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

Il modello definisce una serie di variabili, come containerImage e manifest, che verranno compilate quando definisci la configurazione. Questo modello da solo crea solo un'unica istanza di macchina virtuale (VM).

Quando utilizzi immagini contenitore nelle istanze Compute Engine, devi anche fornire un file manifest (diverso da un manifest di Deployment Manager) per descrivere a Compute Engine quale immagine contenitore utilizzare. Crea un metodo di supporto chiamato container_helper.[py|jinja] per definire dinamicamente il manifest del contenitore:

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)

Creazione dei modelli frontend

Il frontend di questa app esegue Node.js e consente agli utenti di pubblicare messaggi sulla pagina web. Saranno presenti due gruppi di istanze gestite contenenti ciascuna due istanze: un gruppo di istanze gestite principale e un gruppo di istanze gestite secondario per il bilanciamento del carico.

Per creare questi modelli frontend, segui le istruzioni riportate di seguito.

  1. Creare un modello di istanza.

    Per creare un gruppo di istanze gestite, che è un gruppo di istanze VM identiche gestite centralmente, è necessaria una risorsa Modello di istanza. Questo esempio crea un gruppo di istanze gestite per le istanze node.js frontend, ma prima devi creare il modello di istanza.

    Definisci un file denominato 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 gruppo di istanze gestite con scalabilità automatica.

    Ora che hai un modello di istanza, puoi definire un modello che lo utilizzi per creare un gruppo di istanze gestite a scalabilità automatica. Crea un nuovo file denominato autoscaled_group.[py|jinja] con i seguenti contenuti:

    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 il file dello schema corrispondente:

    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 risorse utilizzando questi modelli.

    Fino a questo punto, hai definito i modelli di base che determinano le proprietà delle tue risorse. Utilizza questi modelli per definire la configurazione del frontend. Crea un nuovo file denominato service.[py|jinja] con i seguenti contenuti:

    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 il file dello schema corrispondente:

    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

    Analizziamo cosa viene creato da questo modello:

    1. Due gruppi di istanze gestite, uno principale e uno secondario.

      Il modello utilizza il modello autoscaled_group.[py|jinja] per creare un gruppo di istanze gestite a scalabilità automatica principale e secondario.

    2. Successivamente, il modello crea un servizio di backend e un controllo di integrità. Per il bilanciamento del carico HTTP è necessario un servizio di backend che definisce la capacità di gestione dei gruppi di istanze in quel servizio di backend. In questo caso, i gruppi di istanze gestite principali e secondari fanno parte di questo backend e vengono applicate le proprietà predefinite del servizio di backend.

      Per impostazione predefinita, un servizio di backend esegue il bilanciamento del carico in base all'utilizzo della CPU dei gruppi di istanze associati, ma puoi anche eseguire il bilanciamento del carico in base alle richieste al secondo (RPS).

      Nota:un controllo di integrità è sempre obbligatorio quando crei un servizio di backend.

Creazione di un modello unificante

Infine, crea un modello unificato che combini i modelli di backend e frontend. Crea un nuovo file denominato 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 file di schema corrispondente:

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

Oltre al frontend e al backend, il modello definisce anche alcune risorse aggiuntive:

  1. Un servizio statico con gruppi di istanze gestite principali e secondari. Questo servizio statico pubblica una pagina web nel percorso /static della tua app.

  2. Una risorsa mappa URL. Il bilanciamento del carico HTTP richiede una mappa URL per mappare i diversi URL ai percorsi corretti. In questo caso, il percorso predefinito, indicato dalla proprietà defaultService, è il servizio di backend che hai creato in precedenza. Se un utente accede a /static, la mappa URL mapperà questo percorso al servizio statico, come definito nella sezione pathMatchers.

  3. Una regola di forwarding globale e un proxy HTTP di destinazione. Poiché il bilanciamento del carico dell'app avviene su due zone distinte, è necessaria una regola di inoltro globale che indirizzi un singolo indirizzo IP esterno. Inoltre, per la configurazione del bilanciamento del carico HTTP è necessario un proxy HTTP di destinazione.

  4. Una regola firewall che consenta il traffico tramite la porta 8080.

Creazione della configurazione

Ora che hai a disposizione i modelli e gli schemi correlati, puoi creare una configurazione che esegue il deployment di queste risorse. Crea un file di configurazione denominato application.yaml con i seguenti contenuti e sostituisci ZONE_TO_RUN e SECONDARY_ZONE_TO_RUN con le zone principali e secondarie che preferisci.

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

Deployment della configurazione

Ora esegui il deployment delle risorse. Utilizzando Google Cloud CLI, esegui il seguente comando, eventualmente scegliendo di sostituire advanced-configuration-l7 con un nome di deployment a tua scelta. Tieni presente che il nome del deployment verrà utilizzato automaticamente per assegnare un nome alle risorse.

In questo esempio, il nome del deployment è advanced-configuration-l7. Se scegli di cambiare il nome del deployment, assicurati di utilizzarlo in tutti i seguenti esempi.

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

La risposta dovrebbe essere simile alle seguenti risorse:

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  []

Aggiunta di etichette di servizio

Quindi, specifica le etichette dei servizi appropriate per i gruppi di istanze gestite. Le etichette dei servizi sono metadati utilizzati dal servizio di bilanciamento del carico per raggruppare le risorse.

Per aggiungere le etichette dei servizi, esegui i seguenti comandi, associando le zone principali e secondarie a quelle selezionate nel file di configurazione del deployment:

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]

Testare la configurazione

Per testare la configurazione, recupera l'indirizzo IP esterno che gestisce il traffico eseguendo una query sulla regola di inoltro:

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

In questo caso, l'IP esterno è 107.178.249.126.

In un browser, visita l'indirizzo IP esterno sulla porta 8080. Ad esempio, se il tuo indirizzo IP esterno è 107.178.249.126, l'URL sarà:

http://107.178.249.126:8080

Dovresti visualizzare una pagina vuota, come previsto. Poi, pubblica un messaggio sulla pagina. Vai al seguente URL:

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

Verrà visualizzata la conferma dell'aggiunta del messaggio. Torna all'URL principale. Nella pagina dovrebbe essere visualizzato il messaggio:

hello_world!

Puoi anche visitare la pagina statica che hai creato o controllare l'integrità della tua app visitando i seguenti URL:

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

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

Complimenti, hai eseguito il deployment della configurazione.

(Facoltativo) Creazione di immagini Docker

Docker ti consente di automatizzare ed eseguire software all'interno di container. I container consentono di isolare diversi servizi all'interno di container che possono essere eseguiti su una singola istanza Linux.

Questo esempio ha utilizzato alcune immagini Docker esistenti, ma puoi anche creare le tue versioni di queste immagini Docker. Puoi trovare le istruzioni per creare le immagini di backend MySQL e le immagini di frontend Node.js nella sezione Creare i modelli di risorse.

Per creare l'immagine Docker che serve la pagina web statica:

  1. Crea una nuova istanza VM con un'immagine ottimizzata per i container:

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

  2. Connettiti all'istanza:

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

  3. Crea un file denominato Dockerfile con i seguenti contenuti:

    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 file denominato service.js con i seguenti contenuti:

    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. Crea l'immagine Docker sostituendo username con il tuo nome utente di Docker Hub. Se non hai un nome utente Docker Hub, creane uno prima di creare l'immagine Docker.

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

  6. Esegui il push delle immagini nel repository Docker:

    sudo docker push username/nodejsservicestatic

Ora hai le immagini Docker per eseguire Node.js e MySQL. Puoi visualizzare queste immagini nel repository cercando i nomi delle immagini. Per provare le immagini, puoi sostituire tutte le occorrenze di gcr.io/deployment-manager-examples/mysql e gcr.io/deployment-manager-examples/nodejsservice con le rispettive immagini.

Passaggi successivi

Una volta completato questo esempio, puoi:

  • Continua a sviluppare questo esempio creando una pagina web più solida o aggiungendo altri servizi al server web.
  • Scopri di più sulle configurazioni o sui deployment.
  • Prova a creare le tue configurazioni.