Logbook-Anwendung mit HTTP-Load-Balancing erstellen

Dieses erweiterte Beispiel zeigt, wie eine Logbook-Anwendung erstellt wird, die node.js für das Frontend und MySQL als Backend verwendet. Die Vorlage erstellt und verbindet auch einen HTTP-Load-Balancer, der Lasten zwischen zwei Zonen ausgleicht, sowie ein Autoscaling, das die Anwendung automatisch skaliert.

Deployment-Ressourcen mit HTTP-Load-Balancing
Deployment-Ressourcen mit HTTP-Load-Balancing (zum Vergrößern klicken)

In diesem Beispiel wird angenommen, dass Sie mit Docker-Containern und Compute Engine-Ressourcen, insbesondere HTTP-Load-Balancing, Autoscaling, verwalteten Instanzgruppen und Instanzvorlagen, vertraut sind.

Weitere einführende Informationen finden Sie im Startleitfaden oder in der detaillierten Anleitung.

Hinweis

Vorlagen erstellen

Dieses Beispiel startet ein Deployment mit mehreren Typen von Ressourcen. Zunächst erstellen Sie wiederverwendbare Vorlagen, durch die diese Ressourcen separat definiert werden. Später nutzen Sie diese Vorlagen in Ihrer endgültigen Konfiguration.

Am Ende dieses Beispiels haben Sie eine Bereitstellung, die diese Ressourcen enthält:

  • Eine einzige Compute Engine-Instanz für die Back-End-MySQL-VM.
  • Eine Instanzvorlage, die ein Docker-Image verwendet.
  • Zwei automatisch skalierte, verwaltete Instanzgruppen in zwei verschiedenen Zonen, die den Frontend-Node.js-Dienst ausführen.
  • Weitere zwei automatisch skalierte, verwaltete Instanzgruppen, die statische Daten liefern.
  • Eine Systemdiagnose und einen HTTP-Load-Balancer für die Verteilung von Traffic über die jeweiligen verwalteten Instanzgruppen.

Back-End-Vorlagen erstellen

Das Back-End dieser Anwendung ist eine einzelne Compute Engine-Instanz, auf der ein MySQL Docker-Container ausgeführt wird. Erstellen Sie eine Vorlage, in der eine Compute-Engine Instanz definiert ist, die ein containeroptimiertes Image verwendet. Benennen Sie die Datei container_vm.[py|jinja]:

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

Die Vorlage definiert eine Reihe von Variablen wie containerImage und manifest, die ausgefüllt werden, wenn Sie die Konfiguration erstellen. Diese Vorlage allein erstellt nur eine einzelne VM-Instanz.

Wenn Sie Container-Images auf Compute Engine-Instanzen verwenden, müssen Sie auch eine Manifestdatei angeben (anders als ein Deployment Manager-Manifest), um für Compute Engine zu beschreiben, welches Container-Image verwendet werden soll. Erstellen Sie eine Hilfsmethode mit dem Namen container_helper.[py|jinja], um das Container-Manifest dynamisch zu definieren:

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)

Front-End-Vorlagen erstellen

Das Front-End dieser Anwendung führt Node.js aus und erlaubt Nutzern, Nachrichten auf der Webseite zu posten. Es wird zwei verwaltete Instanzgruppen geben, die jeweils zwei Instanzen enthalten: eine primäre verwaltete Instanzgruppe und eine sekundäre verwaltete Instanzgruppe für das Load-Balancing.

Folgen Sie der Anleitung unten, um Front-End-Vorlagen zu erstellen.

  1. Erstellen Sie eine Instanzvorlage.

    Sie benötigen eine Instanzvorlagen-Ressource, um eine verwaltete Instanzgruppe zu erstellen, d. h. eine Gruppe identischer VM-Instanzen, die zentral verwaltet werden. In diesem Beispiel wird eine verwaltete Instanzgruppe für die node.js-Front-End-Instanzen erstellt, aber erstellen Sie zuerst eine Instanzvorlage.

    Definieren Sie eine Datei mit dem Namen 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. Automatisch skalierte und verwaltete Instanzgruppe erstellen

    Mit dieser Instanzvorlage können Sie jetzt eine Vorlage definieren, die die Instanzvorlage verwendet, um eine automatisch skalierte verwaltete Instanzgruppe zu erstellen. Erstellen Sie eine neue Datei mit dem Namen autoscaled_group.[py|jinja] und folgendem Inhalt:

    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}

    Erstellen Sie die entsprechende Schemadatei:

    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. Erstellen Sie Ressourcen, die diese Vorlagen verwenden.

    Bis hier haben Sie Basisvorlagen definiert, die die Attribute Ihrer Ressourcen bestimmen. Definieren Sie mithilfe dieser Vorlagen die Einrichtung Ihres Front-Ends. Erstellen Sie eine neue Datei mit dem Namen service.[py|jinja] und folgendem Inhalt:

    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}

    Erstellen Sie die entsprechende Schemadatei:

    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

    Sehen wir uns an, was diese Vorlage erstellt:

    1. Zwei verwaltete Instanzgruppen, eine primäre und eine sekundäre.

      Die Vorlage verwendet die Vorlage autoscaled_group.[py|jinja], um eine primäre und sekundäre verwaltete Instanzgruppe mit Autoscaling zu erstellen.

    2. Als Nächstes erstellt die Vorlage einen Back-End-Dienst und eine Systemdiagnose. Für das HTTP-Load Balancing ist ein Back-End-Dienst erforderlich. Er definiert die Bereitstellungskapazität der Instanzgruppen in diesem Back-End-Dienst. In diesem Fall sind die primären und sekundären verwalteten Instanzgruppen Teil des Back-Ends und die Standardattribute des Back-End-Dienstes finden Anwendung.

      Standardmäßig führt ein Back-End-Dienst das Load Balancing basierend auf der CPU-Auslastung der verbundenen Instanzgruppen durch, aber Sie können das Load Balancing auch basierend auf Anfragen pro Sekunde (RPS) durchführen.

      Hinweis: Wenn ein Back-End-Dienst erstellt wird, ist immer eine Systemdiagnose notwendig.

Einheitliche Vorlage erstellen

Erstellen Sie schließlich eine gemeinsame Vorlage, die die Backend- und Frontend-Vorlage miteinander kombiniert. Erstellen Sie eine neue Datei mit dem Namen 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}

Erstellen Sie eine zugehörige Schemadatei:

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

Die Vorlage definiert zusätzlich zum Frontend und Backend noch weitere Ressourcen:

  1. Einen statischen Dienst mit primären und sekundären verwalteten Instanzgruppen. Dieser statische Dienst stellt eine Webseite bereit, die sich unter dem Pfad /static in Ihrer Anwendung befindet.

  2. Eine URL-Zuordnungsressource. Das HTTP-Load-Balancing benötigt eine URL-Zuordnung, um die verschiedenen URLs den richtigen Pfaden zuzuordnen. In diesem Fall ist der durch das Attribut defaultService angegebene Standardpfad der Back-End-Dienst, den Sie zuvor erstellt haben. Falls ein Nutzer /static aufruft, ordnet die URL-Zuordnung diesen Pfad dem statischen Dienst, wie im Abschnitt pathMatchers definiert, zu.

  3. Eine globale Weiterleitungsregel und einen Ziel-HTTP-Proxy. Da das Load-Balancing für die Anwendung in zwei verschiedenen Zonen stattfindet, benötigen Sie eine globale Weiterleitungsregel für eine einzelne externe IP-Adresse. Zusätzlich benötigen Sie einen Ziel-HTTP-Proxy für die Einrichtung des HTTP-Load-Balancing.

  4. Eine Firewallregel, die Traffic über Port 8080 erlaubt.

Konfiguration erstellen

Mit Ihren Vorlagen und den verknüpften Schemas können Sie eine Konfiguration erstellen, die diese Ressourcen bereitstellt. Erstellen Sie eine Konfigurationsdatei mit dem Namen application.yaml und folgendem Inhalt und ersetzen Sie ZONE_TO_RUN und SECONDARY_ZONE_TO_RUN durch die primäre und sekundäre Zone Ihrer Wahl.

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

Konfiguration bereitstellen

Jetzt können Sie Ihre Ressourcen bereitstellen. Führen Sie über die Google Cloud CLI den folgenden Befehl aus. Optional können Sie dabei advanced-configuration-l7 durch einen Deployment-Namen Ihrer Wahl ersetzen. Beachten Sie, dass Ihr Bereitstellungsname automatisch verwendet wird, um die Ressourcen zu benennen.

In diesem Beispiel lautet der Deployment-Name advanced-configuration-l7. Denken Sie daran, diesen Deployment-Namen in allen folgenden Beispielen zu verwenden, falls Sie sich dazu entscheiden, den Namen des Deployments zu ändern.

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

Die Antwort sollte ähnlich aussehen, wie die folgenden Ressourcen:

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

Dienstlabels hinzufügen

Legen Sie als Nächstes die passenden Dienst-Labels für ihre verwalteten Instanzgruppen fest. Dienst-Labels sind Metadaten, die von den Load-Balancing-Diensten zur Gruppierung von Ressourcen verwendet werden.

Führen Sie die folgenden Befehle aus, wobei Sie für die primäre und sekundäre Zone die Zonen angeben, die Sie in der Konfigurationsdatei für Ihr Deployment ausgewählt haben, um Dienst-Labels hinzuzufügen:

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]

Konfiguration testen

Rufen Sie zum Testen Ihrer Konfiguration die externe IP-Adresse ab, über die der Datenverkehr läuft, indem Sie die Weiterleitungsregel abfragen:

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

In diesem Fall lautet die externe IP 107.178.249.126.

Besuchen Sie in einem Browser die externe IP-Adresse über Port 8080. Wenn beispielsweise Ihre externe IP 107.178.249.126 ist, lautet die URL:

http://107.178.249.126:8080

Es sollte eine leere Seite angezeigt werden. Posten Sie dann eine Nachricht auf der Seite. Wechseln Sie zur folgenden URL:

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

Es wird bestätigt, dass Ihre Nachricht hinzugefügt wurde. Navigieren Sie zurück zur Haupt-URL und die Seite sollte jetzt folgende Meldung enthalten:

hello_world!

Sie können auch die von Ihnen erstellte statische Seite besuchen oder eine Systemdiagnose Ihrer Anwendung durchführen, indem Sie die folgenden URLs aufrufen:

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

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

Gratulation! Sie haben Ihre Konfiguration erfolgreich bereitgestellt.

Docker-Images erstellen (optional)

Docker ermöglicht die Automatisierung und Ausführung von Software in Containern. Container erlauben es Ihnen, verschiedene Dienste in Containern zu isolieren, die alle auf einer einzelnen Linux-Instanz ausgeführt werden können.

In diesem Beispiel werden einige vorhandene Docker-Images verwendet, aber Sie können auch eigene Versionen dieser Docker-Images erstellen. Anleitungen zum Erstellen der MySQL-Backend-Images und Node.js-Frontend-Images finden Sie im Abschnitt Ressourcenvorlagen erstellen.

So erstellen Sie das Docker-Image, das von der statischen Webseite verwendet wird:

  1. Erstellen Sie eine neue VM-Instanz mit einem containeroptimierten Image:

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

  2. Stellen Sie eine Verbindung zur Instanz her:

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

  3. Erstellen Sie eine Datei mit dem Namen Dockerfile und folgendem Inhalt:

    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. Erstellen Sie eine Datei mit dem Namen service.js und folgendem Inhalt:

    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. Erstellen Sie das Docker-Image und ersetzen Sie dabei username durch Ihren Docker Hub-Nutzernamen. Wenn Sie keinen Docker Hub-Nutzernamen haben, erstellen Sie einen, bevor Sie das Docker-Image erstellen.

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

  6. Verschieben Sie die Images in das Docker-Repository:

    sudo docker push username/nodejsservicestatic

Jetzt haben Sie die Docker-Images, um Node.js und MySQL auszuführen. Diese Images können im Repository angezeigt werden. Suchen Sie dazu nach den Image-Namen. Wenn Sie die Images ausprobieren möchten, ersetzen Sie alle Instanzen von gcr.io/deployment-manager-examples/mysql und gcr.io/deployment-manager-examples/nodejsservice durch die entsprechenden Images.

Tipp

Wenn Sie dieses Beispiel abgeschlossen haben, können Sie:

  • Auf diesem Beispiel aufbauen, indem Sie eine robustere Webseite erstellen oder dem Webserver weitere Dienste hinzufügen.
  • Mehr über Konfigurationen und Deployments lesen.
  • Eigene Konfigurationen erstellen.