Men-deploy aplikasi logbook load balancer jaringan

Dalam tutorial ini, Anda akan men-deploy contoh aplikasi logbook yang menggunakan Node.js untuk frontend-nya dan MySQL untuk backend-nya. Di akhir tutorial, deployment Anda akan memiliki resource berikut:

Resource deployment load balancing jaringan (klik untuk memperbesar)

Jika Anda baru menggunakan Deployment Manager, lihat tutorial Panduan Memulai atau Panduan Langkah demi Langkah.

Sebelum memulai

Membuat template resource

Contoh ini meluncurkan deployment yang berisi berbagai resource Google Cloud. Untuk memulai, Anda membuat template yang menentukan resource ini secara terpisah. Nanti, Anda akan memanggil template ini dalam konfigurasi akhir. Deployment Anda berisi resource berikut:

  • Instance Compute Engine yang menghosting database MySQL untuk aplikasi.
  • Template instance untuk instance frontend, yang menggunakan image Docker untuk aplikasi Node.js.
  • Grup instance terkelola, yang menggunakan template instance untuk membuat dua instance frontend.
  • Autoscaler, yang memulai atau menghentikan instance frontend tambahan berdasarkan traffic masuk.
  • Health check, yang memeriksa apakah instance frontend tersedia untuk melakukan pekerjaan.
  • Load balancer jaringan dengan aturan penerusan.
  • Kumpulan target untuk grup instance terkelola.

Membuat template untuk backend MySQL

Backend aplikasi ini adalah satu instance Compute Engine yang menjalankan penampung Docker MySQL. Template container_vm.py menentukan instance Compute Engine yang dapat menjalankan container Docker. Untuk memastikan bahwa template mengikuti struktur yang benar dan berisi semua properti yang diperlukan, Anda juga memerlukan file skema.

Salin template di bawah, atau download dari repositori GitHub:

# Copyright 2016 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Creates a Container VM with the provided Container manifest."""

from container_helper import GenerateManifest


COMPUTE_URL_BASE = 'https://www.googleapis.com/compute/v1/'


def GlobalComputeUrl(project, collection, name):
  return ''.join([COMPUTE_URL_BASE, 'projects/', project,
                  '/global/', collection, '/', name])


def ZonalComputeUrl(project, zone, collection, name):
  return ''.join([COMPUTE_URL_BASE, 'projects/', project,
                  '/zones/', zone, '/', collection, '/', name])


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

  base_name = context.env['name']

  # Properties for the container-based instance.
  instance = {
      'zone': context.properties['zone'],
      'machineType': ZonalComputeUrl(context.env['project'],
                                     context.properties['zone'],
                                     'machineTypes',
                                     'f1-micro'),
      'metadata': {
          'items': [{
              'key': 'gce-container-declaration',
              'value': GenerateManifest(context)
              }]
          },
      'disks': [{
          'deviceName': 'boot',
          'type': 'PERSISTENT',
          'autoDelete': True,
          'boot': True,
          'initializeParams': {
              'diskName': base_name + '-disk',
              'sourceImage': GlobalComputeUrl('cos-cloud',
                                              'images',
                                              context.properties[
                                                  'containerImage'])
              },
          }],
      'networkInterfaces': [{
          'accessConfigs': [{
              'name': 'external-nat',
              'type': 'ONE_TO_ONE_NAT'
              }],
          'network': GlobalComputeUrl(context.env['project'],
                                      'networks',
                                      'default')
          }],
        'serviceAccounts': [{
            'email': 'default',
            'scopes': ['https://www.googleapis.com/auth/logging.write']
            }]
      }

  # Resources to return.
  resources = {
      'resources': [{
          'name': base_name,
          'type': 'compute.v1.instance',
          'properties': instance
          }]
      }

  return resources

Download file skema untuk template.

Template memiliki beberapa properti yang tidak ditentukan, seperti containerImage, yang ditentukan dalam template berikutnya.

Saat menggunakan image container di instance Compute Engine, Anda juga perlu menyediakan file manifes yang menjelaskan image container yang akan digunakan. Buat metode helper yang disebut container_helper.py untuk menentukan manifes penampung secara dinamis:

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

Membuat template untuk frontend Node.js

Frontend aplikasi menjalankan Node.js, dan memungkinkan pengguna memposting pesan ke halaman web. Frontend berjalan di grup instance virtual machine, yang didukung oleh autoscaler dan load balancer. Untuk membuat template frontend, gunakan petunjuk berikut.

  1. Buat resource template instance.

    Anda memerlukan template instance untuk membuat grup instance terkelola, yang merupakan grup instance virtual machine (VM) identik yang Anda kontrol sebagai satu entity.

    Buat file bernama container_instance_template.py, lalu download skema untuk template:

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

    Download file skema untuk template.

  2. Buat autoscaler, grup instance terkelola, dan load balancer.

    Selanjutnya, buat template lain yang menggunakan template container_instance_template.py dan membuat resource frontend lainnya, termasuk autoscaler, load balancer, dan grup instance terkelola.

Template ini menyertakan resource berikut:

  1. Template instance menggunakan template container_instance_template.py.

  2. Grup instance terkelola yang menggunakan template instance, dan autoscaler yang mereferensikan grup instance terkelola. Penggunaan referensi memastikan bahwa Deployment Manager membuat resource dalam urutan tertentu. Dalam hal ini, grup instance terkelola dibuat sebelum autoscaler.

  3. Load balancer jaringan yang berisi resource berikut:

    • Aturan penerusan dengan satu alamat IP eksternal yang ditampilkan ke Internet.
    • Kumpulan target yang berisi grup instance terkelola yang Anda buat sebelumnya.
    • Health check yang akan dilampirkan ke kumpulan target.

Buat file bernama frontend.py, lalu download skema untuk template:

# Copyright 2016 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Creates autoscaled, network LB IGM running specified docker image."""


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

  # Pull the region out of the zone
  region = context.properties['zone'][:context.properties['zone'].rfind('-')]
  name = context.env['name']

  resources = [{
      'name': name,
      'type': 'container_instance_template.py',
      'properties': {
          'port': context.properties['port'],
          'dockerEnv': context.properties['dockerEnv'],
          'dockerImage': context.properties['dockerImage'],
          'containerImage': context.properties['containerImage']
      }
  }, {
      'name': name + '-igm',
      'type': 'compute.v1.instanceGroupManager',
      'properties': {
          'zone': context.properties['zone'],
          'targetSize': context.properties['size'],
          'targetPools': ['$(ref.' + name + '-tp.selfLink)'],
          'baseInstanceName': name + '-instance',
          'instanceTemplate': '$(ref.' + name + '-it.selfLink)'
      }
  }, {
      'name': name + '-as',
      'type': 'compute.v1.autoscaler',
      'properties': {
          'zone': context.properties['zone'],
          'target': '$(ref.' + name + '-igm.selfLink)',
          'autoscalingPolicy': {
              'maxNumReplicas': context.properties['maxSize']
          }
      }
  }, {
      'name': name + '-hc',
      'type': 'compute.v1.httpHealthCheck',
      'properties': {
          'port': context.properties['port'],
          'requestPath': '/_ah/health'
      }
  }, {
      'name': name + '-tp',
      'type': 'compute.v1.targetPool',
      'properties': {
          'region': region,
          'healthChecks': ['$(ref.' + name + '-hc.selfLink)']
      }
  }, {
      'name': name + '-lb',
      'type': 'compute.v1.forwardingRule',
      'properties': {
          'region': region,
          'portRange': context.properties['port'],
          'target': '$(ref.' + name + '-tp.selfLink)'
      }
  }]
  return {'resources': resources}

Download file skema untuk template.

Membuat template pemersatu

Terakhir, buat template yang menggabungkan template backend dan frontend. Buat file bernama nodejs.py dengan konten berikut:

# Copyright 2016 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Create nodejs template with the back-end and front-end templates."""


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

  backend = context.env['deployment'] + '-backend'
  frontend = context.env['deployment'] + '-frontend'
  firewall = context.env['deployment'] + '-application-fw'
  application_port = 8080
  mysql_port = 3306
  resources = [{
      'name': backend,
      'type': 'container_vm.py',
      'properties': {
          'zone': context.properties['zone'],
          'dockerImage': 'gcr.io/qwiklabs-resources/mysql',
          'containerImage': 'family/cos-stable',
          'port': mysql_port,
          'dockerEnv': {
              'MYSQL_ROOT_PASSWORD': 'mypassword'
          }
      }
  }, {
      'name': frontend,
      'type': 'frontend.py',
      'properties': {
          'zone': context.properties['zone'],
          'dockerImage': 'gcr.io/qwiklabs-resources/nodejsservice',
          'port': application_port,
          # Define the variables that are exposed to container as env variables.
          'dockerEnv': {
              'SEVEN_SERVICE_MYSQL_PORT': mysql_port,
              'SEVEN_SERVICE_PROXY_HOST': '$(ref.' + backend
                                          + '.networkInterfaces[0].networkIP)'
          },
          # If left out will default to 1
          'size': 2,
          # If left out will default to 1
          'maxSize': 20
      }
  }, {
      'name': firewall,
      'type': 'compute.v1.firewall',
      'properties': {
          'allowed': [{
              'IPProtocol': 'TCP',
              'ports': [application_port]
          }],
          'sourceRanges': ['0.0.0.0/0']
      }
  }]
  return {'resources': resources}

Download file skema untuk template.

Perhatikan bahwa frontend aplikasi Anda bernama env["deployment"]-frontend, dan backend Anda juga diberi nama yang sama. Saat Anda men-deploy aplikasi, Deployment Manager akan otomatis mengganti env["deployment"] dengan nama deployment.

Membuat konfigurasi

Setelah semua template siap, Anda dapat membuat konfigurasi yang akan digunakan untuk men-deploy resource. Buat file konfigurasi bernama nodejs.yaml dengan konten berikut:

# Copyright 2016 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Launches an autoscaled, load-balanced frontend running nodejs for serving
# traffic. Also launches a single MySQL container instance, wires the two
# together using references, and passes them as env variables to the underlying
# frontend Docker containers.
imports:
- path: nodejs.py

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

Ganti ZONE_TO_RUN dengan zona tempat Anda menginginkan resource, seperti us-central1-a.

Mendeploy resource Anda

Sekarang, deploy resource Anda. Dengan menggunakan Google Cloud CLI, jalankan:

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

Setelah deployment selesai, Deployment Manager akan menampilkan ringkasan resource yang dibuat, mirip dengan berikut ini:

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

Menguji aplikasi

Untuk menguji aplikasi, dapatkan alamat IP eksternal yang menyalurkan traffic terlebih dahulu, dengan mengajukan kueri aturan penerusan:

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

Dalam hal ini, IP eksternal adalah 104.154.81.44.

Selanjutnya, di browser, buka alamat IP eksternal dengan port 8080. Misalnya, jika alamat IP eksternal Anda adalah 104.154.81.44, URL-nya adalah:

http://104.154.81.44:8080

Anda akan melihat halaman kosong, yang diharapkan. Selanjutnya, posting pesan ke halaman. Buka URL berikut:

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

Anda akan melihat konfirmasi bahwa pesan Anda telah ditambahkan. Kembali ke URL utama, dan halaman kini akan menampilkan pesan:

hellothere!

Sekarang Anda memiliki aplikasi yang di-deploy yang dapat mencatat pesan yang dikirim ke aplikasi tersebut.

Langkah berikutnya

Setelah menyelesaikan contoh ini, Anda dapat: