Como criar um aplicativo de registro de ocorrências no balanceamento de carga HTTP

Este exemplo avançado demonstra como criar um aplicativo de registro de ocorrências que usa node.js para o front-end e MySQL para o back-end. O modelo também cria e conecta um balanceador de carga HTTP, que faz o balanceamento de carga entre duas zonas, e um autoescalador, para fazer o escalonamento automático do aplicativo.

Este exemplo pressupõe que você tenha familiaridade com contêineres Docker e recursos do Compute Engine, especialmente balanceamento de carga HTTP, escalonamento automático, grupos de instâncias gerenciadas e modelos de instância.

Para mais tutoriais introdutórios, consulte o Guia de primeiros passos ou o Guia passo a passo.

Antes de começar

• Para usar os exemplos de linha de comando deste guia, instale a ferramenta de linha de comando "gcloud".
• Para usar os exemplos de API deste guia, configure o acesso de API.
• Familiarize-se com o balanceamento de carga HTTP do Compute Engine.
• Familiarize-se com os contêineres Docker.

Como criar modelos

Neste exemplo, iniciamos inicia uma implantação com diversos tipos de recursos. Para começar, você criará modelos reutilizáveis que definem esses recursos separadamente. Posteriormente, você os usará na configuração final.

Ao final deste exemplo, você terá uma implantação com os seguintes recursos:

• uma única instância do Compute Engine para a máquina virtual MySQL back-end
• um modelo de instância que usa uma imagem Docker
• dois grupos de instâncias gerenciadas em escalonamento automático em duas zonas diferentes, executando o serviço node.js front-end
• outros dois grupos de instâncias gerenciadas em escalonamento automático que fornecem dados estáticos
• uma verificação de integridade e um balanceador de carga HTTP para tráfego distribuído em todos os respectivos grupos de instâncias gerenciadas

Como criar os modelos de back-end

O back-end desse aplicativo é uma única instância do Compute Engine que executa um contêiner Docker com o MySQL. Crie um modelo que defina uma instância do Compute Engine que use uma imagem otimizada para contêiner. Coloque o nome de container_vm.[py|jinja] no arquivo:

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

{% 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

# 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

O modelo define um número de variáveis, como containerImage e manifest, que serão preenchidas quando você definir sua configuração. Sozinho, este modelo apenas cria uma única instância de máquina virtual (VM).

Quando você usa imagens de contêiner em instâncias do Compute Engine, também é necessário fornecer um arquivo de manifesto para descrever qual imagem usar. Esse manifesto é diferente do utilizado pelo Deployment Manager. Crie um método auxiliar chamado container_helper.[py|jinja] para definir dinamicamente o manifesto do contêiner:

{% 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 -%}

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

Como criar os modelos de front-end

O front-end deste aplicativo executa o Node.js e permite que os usuários postem mensagens na página da Web. Haverá dois grupos de instâncias gerenciadas contendo duas instâncias cada: um grupo de instâncias gerenciadas principal e um grupo de instâncias gerenciadas secundário para o balanceamento de carga.

Para criar modelos de front-end, use as instruções a seguir.

1. Crie um modelo de instância.

   Você precisa de um recurso de modelo de instância para criar um grupo de instâncias gerenciadas, que é um grupo de instâncias de VM idênticas gerenciadas centralmente. Este exemplo cria um grupo de instâncias gerenciadas para as instâncias node.js front-end, mas antes é preciso criar o modelo de instância.

   Defina um arquivo chamado container_instance_template.[py|jinja]:

   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.
   #}
   
   {% 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. Crie um grupo de instâncias gerenciadas com escalonamento automático.

   Agora que você tem um modelo de instância, defina um modelo que use o modelo de instância para criar um grupo de instâncias gerenciadas de escalonamento automático. Crie um novo arquivo chamado autoscaled_group.[py|jinja] com o seguinte conteúdo:

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

   Crie o arquivo de esquema correspondente:

   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. Crie recursos usando esses modelos.

   Até este ponto, você definiu modelos base que determinam as propriedades dos recursos. Use esses modelos para definir a configuração do front-end. Crie um novo arquivo chamado service.[py|jinja] com o seguinte conteúdo:

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

   Crie o arquivo de esquema correspondente:

   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
   

   Detalhemos o que esse modelo está criando:

   1. Dois grupos de instâncias gerenciadas, um principal e outro secundário.

      O modelo usa o modelo autoscaled_group.[py|jinja] para criar um grupo de instâncias gerenciado, com escalonamento automático principal e secundário.

   2. Em seguida, o modelo cria um serviço back-end e um verificador de integridade. Um serviço back-end é necessário para o balanceamento de carga HTTP e define a capacidade de distribuição dos grupos de instâncias nesse serviço back-end. Nesse caso, os grupos de instâncias gerenciadas principal e secundário fazem parte desse back-end, e as propriedades padrão do serviço back-end são aplicáveis.

      Por padrão, um serviço de back-end realiza o balanceamento de carga com base na utilização da CPU dos grupos de instâncias associadas, mas você também pode equilibrar a carga com base em solicitações por segundo (RPS, na sigla em inglês).

      Observação: uma verificação de integridade sempre é obrigatória durante a criação de um serviço de back-end.

Como criar um modelo unificado

Por fim, crie um modelo unificador que combine os modelos back-end e front-end. Crie um novo arquivo denominado application.[py|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.
#}

{% 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 ]

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

Crie um arquivo de esquema correspondente:

# 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

# 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

Além do front-end e do back-end, o modelo também define alguns recursos adicionais:

1. Um serviço estático com grupos de instâncias gerenciadas principal e secundário. Esse serviço estático exibe uma página da Web, localizada no caminho /static do seu aplicativo.

2. Um recurso de mapa URL. O balanceamento de carga HTTP exige um mapa URL para mapear os URLs diferentes para os caminhos corretos. Nesse caso, o caminho padrão, indicado pela propriedade defaultService, é o serviço de back-end que você criou anteriormente. Se um usuário navegar para /static, o mapa de URLs mapeará esse caminho para o serviço estático, conforme definido na seção pathMatchers.

3. Uma regra de encaminhamento global e um proxy HTTP de destino. Como a carga do aplicativo está sendo balanceada entre duas zonas separadas, você precisará de uma regra de encaminhamento global que ofereça um único endereço IP externo. Além disso, um proxy HTTP de destino é obrigatório para a configuração do balanceamento de carga HTTP.

4. Uma regra de firewall que permita o tráfego pela porta 8080.

Como criar a configuração

Agora que tem os modelos e os esquemas relacionados prontos, crie uma configuração que implante esses recursos. Crie um arquivo de configuração chamado application.yaml com o conteúdo a seguir e substitua ZONE_TO_RUN e SECONDARY_ZONE_TO_RUN pelas zonas primária e secundária que você preferir.

# 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

# 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

Como implantar a configuração

Agora, faremos a implantação dos recursos. Usando a Google Cloud CLI, execute o comando a seguir, optando por substituir advanced-configuration-l7 por um nome de implantação de sua escolha. Lembre-se de que o nome da implantação será usado automaticamente para identificar os recursos.

Neste exemplo, o nome da implantação é advanced-configuration-l7. Caso você opte por alterar o nome da implantação, não se esqueça de usá-lo em todos os exemplos a seguir.

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

A resposta deve ser semelhante à resposta dos seguintes 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  []

Como adicionar rótulos de serviço

Em seguida, especifique os rótulos de serviço para os grupos de instâncias gerenciadas. Esses rótulos são metadados usados pelo serviço de balanceamento de carga para agrupar recursos.

Para adicionar rótulos de serviço, execute os seguintes comandos, comparando as zonas primária e secundária com as zonas selecionadas no arquivo de configuração da implantação:

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]

Como testar a configuração

Para testar a configuração, veja o endereço IP externo que exibe o tráfego consultando a regra de encaminhamento:

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

Neste caso, o IP externo é 107.178.249.126.

Em um navegador, visite o endereço IP externo na porta 8080. Por exemplo, se o IP externo for 107.178.249.126, o URL será:

http://107.178.249.126:8080

Aparecerá uma página em branco, o que é esperado. Em seguida, poste uma mensagem na página. Acesse o seguinte URL:

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

Você verá uma confirmação de que a mensagem foi adicionada. Volte ao URL principal, e agora a página terá a mensagem:

hello_world!

Também é possível visitar a página estática criada por você ou verificar a integridade do aplicativo nos seguintes URLs:

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

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

Parabéns, configuração implantada com sucesso.

(Opcional) Como criar imagens do Docker

O Docker permite automatizar e executar software em contêineres. Os contêineres permitem isolar serviços diferentes dentro de contêineres que podem ser todos executados em uma única instância do Linux.

Neste exemplo, algumas imagens do Docker foram usadas, mas você pode criar as próprias versões delas. Veja as instruções para criar as imagens de back-end MySQL e a imagens de front-end do Node.js na seção Criar modelos de recurso.

Para criar a imagem Docker que exibe a página da Web estática:

1. Crie uma nova instância de VM com uma imagem otimizada para contêiner:

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

2. Conecte-se à instância:

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

3. Crie um arquivo chamado Dockerfile com o seguinte conteúdo:

   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. Crie um arquivo chamado service.js com o seguinte conteúdo:

   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. Crie a imagem do Docker, substituindo username pelo seu nome de usuário do Docker Hub. Caso você não tenha um nome de usuário do Docker Hub, crie um antes de criar a imagem Docker.

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

6. Envie as imagens para o repositório do Docker:

   sudo docker push username/nodejsservicestatic
   

Agora você tem as imagens do Docker para executar Node.js e MySQL. Essas imagens podem ser vistas realmente no repositório, basta pesquisar pelos respectivos nomes. Para testar as imagens, substitua todas as instâncias de gcr.io/deployment-manager-examples/mysql e gcr.io/deployment-manager-examples/nodejsservice pelas suas imagens.

Próximas etapas

Após concluir este exemplo, você poderá:

• Continuar a desenvolver a partir dele, criando uma página da Web mais robusta ou adicionando mais serviços ao servidor da Web.
• Leia mais sobre configurações ou implantações.
• tentar criar configurações próprias.