HTTP 부하 분산 로그북 앱 만들기

이 고급 예시에서는 프런트엔드에 node.js를 사용하고 백엔드에 MySQL을 사용하는 로그북 앱을 빌드하는 방법을 설명합니다. 또한 이 템플릿을 통해 두 영역에 부하를 분산하는 HTTP 부하 분산기와 앱을 자동으로 확장하는 자동 확장 처리를 만들고 연결할 수 있습니다.

HTTP 부하가 분산된 배포 리소스

이 예제에서는 사용자가 Docker 컨테이너와 Compute Engine 리소스, 특히 HTTP 부하 분산, 자동 확장, 관리형 인스턴스 그룹, 인스턴스 템플릿에 익숙하다고 가정합니다.

더 많은 입문 가이드는 시작 가이드 또는 단계별 안내를 참조하세요.

시작하기 전에

• 이 가이드의 명령줄 예시를 사용하려면 'gcloud' 명령줄 도구를 설치합니다.
• 이 가이드의 API 예시를 사용하려면 API 액세스를 설정합니다.
• Compute Engine HTTP 부하 분산을 숙지합니다.
• Docker 컨테이너를 숙지합니다.

템플릿 만들기

이 예시에서는 몇 가지 유형의 리소스가 포함된 배포를 시작합니다. 먼저 이러한 리소스를 개별적으로 정의하는 재사용 가능한 템플릿을 만듭니다. 나중에 이 템플릿을 최종 구성에서 사용합니다.

이 예제를 모두 마치면 다음 리소스가 포함된 배포가 준비됩니다.

• 백엔드 MySQL 가상 머신용 단일 Compute Engine 인스턴스
• Docker 이미지를 사용하는 인스턴스 템플릿
• 서로 다른 두 영역에서 프런트엔드 node.js 서비스를 실행하는 2개의 자동 확장된 관리형 인스턴스 그룹
• 정적 데이터를 제공하는 또 다른 2개의 자동 확장된 관리형 인스턴스 그룹
• 각각의 관리형 인스턴스 그룹에 분산된 트래픽에 대한 상태 확인 및 HTTP 부하 분산기

참고: 이 예시에서는 Jinja 또는 Python으로 템플릿을 작성할 수 있습니다. Deployment Manager에서 두 가지 버전을 모두 제공하지만 [py|jinja]가 표시된 곳에 올바른 파일 확장자로 템플릿 파일을 저장해야 합니다. 예를 들어 application.py는 Python 템플릿이고 application.jinja는 Jinja 템플릿입니다.

백엔드 템플릿 만들기

이 앱의 백엔드는 MySQL Docker 컨테이너를 실행하는 단일 Compute Engine 인스턴스입니다. 컨테이너 최적화 이미지를 사용하는 Compute Engine 인스턴스를 정의하도록 템플릿을 만듭니다. 파일 이름을 container_vm.[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 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

이 템플릿에서는 구성을 정의할 때 입력할 containerImage와 manifest와 같은 여러 가지 변수를 정의합니다. 이 템플릿으로는 단일 가상 머신(VM) 인스턴스만 생성됩니다.

Compute Engine 인스턴스에서 컨테이너 이미지를 사용하는 경우, 매니페스트 파일(Deployment Manager 매니페스트와 다름)도 제공하여 어떤 컨테이너 이미지를 사용할지 Compute Engine에 설명해야 합니다. container_helper.[py|jinja]라는 도우미 메서드를 만들어서 컨테이너 매니페스트를 동적으로 정의합니다.

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)

프런트엔드 템플릿 만들기

이 앱의 프런트엔드는 Node.js를 실행하며 사용자가 웹페이지에 메시지를 게시할 수 있도록 합니다. 각각 2개의 인스턴스를 포함하는 관리형 인스턴스 그룹 2개(기본 관리형 인스턴스 그룹과 부하 분산을 위한 보조 관리형 인스턴스 그룹)를 생성합니다.

이러한 프런트엔드 템플릿을 만들려면 다음 안내를 따르세요.

1. 인스턴스 템플릿을 만듭니다.

   중앙에서 관리되는 동일한 VM 인스턴스의 그룹인 관리형 인스턴스 그룹을 만들려면 인스턴스 템플릿 리소스가 필요합니다. 이 예시에서는 프런트엔드 node.js 인스턴스를 위한 관리형 인스턴스 그룹을 만듭니다. 우선 인스턴스 템플릿을 만들어야 합니다.

   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. 자동 확장 관리형 인스턴스 그룹을 만듭니다.

   인스턴스 템플릿을 생성했으므로 이제 이를 사용하여 자동 확장되는 관리형 인스턴스 그룹을 만들도록 템플릿을 정의할 수 있습니다. 다음 콘텐츠로 autoscaled_group.[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.
   #}
   
   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}
   

   해당 스키마 파일을 만듭니다.

   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. 이 템플릿을 사용하여 리소스를 만듭니다.

   지금까지 리소스 속성을 결정하는 기본 템플릿을 정의했습니다. 이 템플릿을 사용하여 프론트엔드 설정을 정의하세요. 다음 콘텐츠로 service.[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.
   #}
   
   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}
   

   해당 스키마 파일을 만듭니다.

   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
   

   이 템플릿으로 생성되는 요소를 분석해 보겠습니다.

   1. 2개의 관리형 인스턴스 그룹(기본 및 보조).

      이 템플릿에서는 autoscaled_group.[py|jinja] 템플릿을 사용하여 자동 확장된 관리형 인스턴스 그룹(기본 및 보조)을 만듭니다.

   2. 다음으로 백엔드 서비스와 상태 확인기를 만듭니다. 백엔드 서비스는 HTTP 부하 분산에 필요하며, 해당 백엔드 서비스에 있는 인스턴스 그룹의 처리 용량을 정의합니다. 이 경우 기본 및 보조 관리형 인스턴스 그룹은 이 백엔드의 일부이며, 백엔드 서비스의 기본 속성이 적용됩니다.

      기본적으로 백엔드 서비스는 연결된 인스턴스 그룹의 CPU 사용률에 따라 부하 분산을 수행하지만 초당 요청(RPS)에 따라 부하를 분산할 수도 있습니다.

      참고: 백엔드 서비스를 만들 때는 항상 상태 확인이 필요합니다.

통합 템플릿 만들기

마지막으로 백엔드 템플릿과 프론트엔드 템플릿을 조합하는 통합 템플릿을 만듭니다. application.[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.
#}

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

해당 스키마 파일을 만듭니다.

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

템플릿에서 프런트엔드와 백엔드 외에 다음과 같은 일부 추가 리소스도 정의합니다.

1. 기본 및 보조 관리형 인스턴스 그룹이 있는 정적 서비스. 이 정적 서비스는 앱의 /static 경로에 있는 웹페이지를 제공합니다.

2. URL 맵 리소스. HTTP 부하 분산 시 서로 다른 URL을 올바른 경로에 매핑하려면 URL 맵이 필요합니다. 이 경우 defaultService 속성으로 표시된 기본 경로는 이전에 만든 백엔드 서비스입니다. 사용자가 /static으로 이동하면 URL 맵은 pathMatchers 섹션에서 정의된 대로 이 경로를 정적 서비스에 매핑합니다.

3. 전역 전달 규칙과 대상 HTTP 프록시. 앱이 별개의 두 영역에 부하 분산되므로 단일 외부 IP 주소를 제공하는 전역 전달 규칙이 필요합니다. 또한 HTTP 부하 분산을 설정하려면 대상 HTTP 프록시가 필요합니다.

4. 포트 8080을 통한 트래픽을 허용하는 방화벽 규칙

구성 만들기

템플릿과 관련 스키마가 준비되었으므로 이제 이러한 리소스를 배포하는 구성을 만들 수 있습니다. 다음 콘텐츠로 application.yaml이라는 구성 파일을 만들고 ZONE_TO_RUN과 SECONDARY_ZONE_TO_RUN을 원하는 기본 영역과 보조 영역으로 바꿉니다.

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

구성 배포 중

이제 리소스를 배포해 보겠습니다. Google Cloud CLI를 사용하여 다음 명령어를 실행합니다. 원하는 경우 advanced-configuration-l7을 원하는 배포 이름으로 바꿉니다. 배포 이름은 리소스 이름을 지정하는 데 자동으로 사용됩니다.

이 예시에서 배포 이름은 advanced-configuration-l7입니다. 배포 이름을 변경하려는 경우 다음 모든 예시에서 이 배포 이름을 사용해야 합니다.

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

응답은 다음 리소스와 비슷해야 합니다.

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

서비스 라벨 추가

다음으로 관리형 인스턴스 그룹에 적절한 서비스 라벨을 지정합니다. 서비스 라벨은 부하 분산 서비스에서 리소스 그룹화에 사용하는 메타데이터입니다.

서비스 라벨을 추가하려면 기본 및 보조 영역을 배포 구성 파일에서 선택한 영역과 일치시켜 다음 명령어를 실행합니다.

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]

구성 테스트

구성을 테스트하려면 전달 규칙을 쿼리하여 트래픽을 제공하는 외부 IP 주소를 가져옵니다.

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

이 경우 외부 IP는 107.178.249.126입니다.

브라우저에서 포트 8080의 외부 IP 주소에 방문합니다. 예를 들어 외부 IP가 107.178.249.126이면 URL은 다음과 같습니다.

http://107.178.249.126:8080

참고: 배포가 완전히 시작되는 데 몇 분 정도 걸릴 수 있습니다. 이 URL에 방문할 때 오류가 표시되면 몇 분 기다렸다가 다시 시도하세요.

예상대로 빈 페이지가 표시되면 메시지를 게시합니다. 다음 URL로 이동합니다.

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

메시지가 추가되었음을 알리는 확인이 표시됩니다. 기본 URL로 돌아가면 페이지에 다음 메시지가 표시됩니다.

hello_world!

다음 URL을 방문하여, 만든 정적 페이지를 확인하거나 앱의 상태를 확인할 수도 있습니다.

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

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

수고하셨습니다. 구성을 성공적으로 배포했습니다.

(선택사항) Docker 이미지 만들기

Docker를 통해 컨테이너 내부에서 소프트웨어를 자동화하고 실행할 수 있습니다. 컨테이너를 사용하면 단일 Linux 인스턴스에서 모두 실행될 수 있는 컨테이너 안에서 여러 서비스를 격리할 수 있습니다.

이 예시에서는 일부 기존 Docker 이미지를 사용했지만 이러한 Docker 이미지 버전을 직접 만들 수도 있습니다. MySQL 백엔드 이미지와 Node.js 프런트엔드 이미지를 만드는 방법은 리소스 템플릿 만들기 섹션에서 확인할 수 있습니다.

정적 웹페이지를 제공하는 Docker 이미지를 만들려면 다음 안내를 따르세요.

1. 컨테이너 최적화 이미지로 새 VM 인스턴스를 만듭니다.

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

2. 인스턴스에 연결합니다.

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

3. 다음 콘텐츠로 Dockerfile이라는 파일을 만듭니다.

   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. 다음 콘텐츠로 service.js라는 파일을 만듭니다.

   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. username을 개발자의 Docker Hub 사용자 이름으로 바꿔 Docker 이미지를 빌드합니다. Docker Hub 사용자 이름이 없으면 먼저 사용자 이름을 만든 후에 Docker 이미지를 빌드합니다.

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

6. 이미지를 Docker 저장소로 푸시합니다.

   sudo docker push username/nodejsservicestatic
   

이제 Node.js와 MySQL을 실행할 Docker 이미지가 생성되었습니다. 이미지 이름을 검색하면 저장소에서 실제로 이 이미지를 볼 수 있습니다. 이미지를 사용해 보려면 gcr.io/deployment-manager-examples/mysql과 gcr.io/deployment-manager-examples/nodejsservice의 모든 인스턴스를 각각의 이미지로 바꾸면 됩니다.

다음 단계

이 샘플을 완료하면 다음을 수행할 수 있습니다.

• 이 예시를 기반으로 계속하여 더 견고한 웹페이지를 만들거나 더 많은 서비스를 웹 서버에 추가합니다.
• configurations 또는 배포에 대해 자세히 알아봅니다.
• 나만의 구성 만들기