Deploying the Python Bookshelf app using Cloud Deployment Manager

This tutorial shows how to deploy the Python Bookshelf sample app using Cloud Deployment Manager.

Deployment Manager lets you create the necessary Google Cloud Platform (GCP) resources for a deployment in a single step, through a declarative, repeatable process. With Deployment Manager, you can update your deployments, track your modifications over time, create templates using Jinja or Python, and parameterize your templates, so that similar deployments share a template.


  • Clone and configure the Bookshelf sample app.
  • Create Deployment Manager configurations and templates.
  • Create Deployment Manager deployments.
  • Deploy the Bookshelf sample app using Deployment Manager.


이 가이드는 Google Cloud Platform의 다음 청구 가능 구성요소를 사용합니다.

가격 계산기를 사용하여 예상 사용량을 기준으로 예상 비용을 생성할 수 있습니다. GCP 신규 사용자는 무료 평가판을 사용할 수 있습니다.

이 가이드를 마치면 만든 리소스를 삭제하여 비용이 계속 청구되지 않게 할 수 있습니다. 자세한 내용은 삭제를 참조하세요.

Before you begin

  1. Google 계정에 로그인합니다.

    아직 계정이 없으면 새 계정을 등록하세요.

  2. Google Cloud Platform 프로젝트를 선택하거나 만듭니다.

    리소스 관리 페이지로 이동

  3. Google Cloud Platform 프로젝트에 결제가 사용 설정되어 있는지 확인하세요.

    결제 사용 설정 방법 알아보기

  4. Cloud Datastore API, Cloud Storage API, Cloud Pub/Sub API APIs를 사용 설정합니다.

    APIs 사용 설정

  5. Cloud SDK 설치 및 초기화.
  6. Install Python, pip, and virtualenv on your system. For instructions, see Setting up a Python development environment.

Creating a Cloud Storage bucket

The following instructions show how to create a Cloud Storage bucket. Buckets are the basic containers that hold your data in Cloud Storage.

  1. In your terminal window, create a Cloud Storage bucket where [YOUR_BUCKET_NAME] represents the name of your bucket:

    gsutil mb gs://[YOUR_BUCKET_NAME]
  2. To view uploaded images in the Bookshelf app, set the bucket's default access control list (ACL) to public-read:

    gsutil defacl set public-read gs://[YOUR_BUCKET_NAME]

Cloning the sample app

The sample app is available on GitHub at GoogleCloudPlatform/getting-started-python.

  1. Clone the repository:

    git clone
  2. Go to the sample directory:

    cd getting-started-python/7-gce

Configuring the app

  1. Open for editing.

    • Set the value of PROJECT_ID to your project ID.

    • Set the value CLOUD_STORAGE_BUCKET to the name of your Cloud Storage bucket.

  2. Save and close

Running the app on your local computer

  1. Create an isolated Python environment, and install dependencies:


    virtualenv -p python3 env
    source env/bin/activate
    pip install -r requirements.txt


    virtualenv -p python3 env
    pip install -r requirements.txt

  2. Run the application:

  3. In your browser, enter the following address:


To stop the local web server, press Control+C. If you want to exit the virtual environment, enter deactivate.

Deploying the sample app

Push your code to a repository

You can get your code onto a running Compute Engine instance in several ways. One way is to use Cloud Source Repositories. Every project includes a Git repository that is available to Compute Engine instances. Your instances then pull the latest version of your app's code during startup. Using a Git repository is convenient because updating your app doesn't require configuring new images or instances; just restart an existing instance or create one.

  1. For your first time using Git, use git config --global to set up your identity.

  2. In your GCP Console, create a repository:

    Create repository

  3. Then push your app code to your project's repository where [YOUR_PROJECT_ID] is your project ID and [YOUR_REPO] is the name of your repository:

    git commit -am "Updating configuration"
    git config credential.helper
    git remote add cloud[YOUR_PROJECT_ID]/r/[YOUR_REPO]
    git push cloud master

Create the deployment

After your configuration is committed and your code is uploaded to Cloud Source Repositories, you can use the Deployment Manager to create the deployment:

  1. Go to the deployment_manager directory:

    cd getting-started-python/7-gce/gce/deployment_manager
  2. Create the deployment:

    gcloud deployment-manager deployments create my-deployment --config config.yaml
  3. View a list of all the deployments:

    gcloud deployment-manager deployments list
  4. Get a description of the deployment and the resources it created:

    gcloud deployment-manager deployments describe my-deployment

View your app

After you create the forwarding rule, it can take several minutes for your configuration to propagate and for traffic to be routed to your instances.

  1. To check the progress:

    gcloud compute backend-services get-health bookshelf-my-deployment-frontend --global
  2. When at least one of your instances reports HEALTHY, get the forwarding IP address for the load balancer:

    gcloud compute forwarding-rules list --global

    Your forwarding-rules IP address is in the IP_ADDRESS column.

  3. In your browser, enter the IP address from the list.

    Your app is now running on GCP.

Understanding the code

Configure the deployment

You can see how the deployment is configured in config.yaml:

- name: bookshelf.jinja
  path: ./bookshelf.jinja

- name: bookshelf
  type: bookshelf.jinja
    zone: us-central1-f
    machine-type: n1-standard-1
    min-instances: 1
    max-instances: 10
    target-utilization: 0.6

The configuration file imports the template file as a resource and uses it to define a resource named bookshelf. The template takes several properties as parameters. For more information about creating Deployment Manager configuration files, see Creating a configuration.

Configure the deployment template's schema

Look at the schema file bookshelf.jinja.schema, which defines and documents the parameters that the deployment is expected to provide in its configuration file. For more information about configuration schemas, see Using schemas.

  title: Bookshelf GCE Deploy
  author: Google Inc.
  description: Creates a GCE Deployment

- name: startup-script
  path: ../

- zone
- machine-type
- min-instances
- max-instances
- scopes

    description: Zone to create the resources in.
    type: string
    description: Type of machine to use
    type: string
    description: The OS image to use on the machines
    type: string
    description: The minimum number of VMs the autoscaler will create
    type: integer
    description: The maximum number of VMs the autoscaler will create
    type: integer
    description: The target CPU usage for the autoscaler to base its scaling on
    type: number
    description: A list of scopes to create the VM with
    type: array
    minItems: 1
      type: string

Configure the deployment template

The template defines several resources needed to create an autoscaled, load- balanced, managed instance group. For a full description of the resources created, see the comments in the template and review the Bookshelf on Compute Engine tutorial.

Keep in mind that Deployment Manager provides a way to declaratively define resources, but most of the configuration for a given resource is defined by its API. For example, most of the configuration options for the instance template resource are found in the instance template resource definition in the reference documentation for the Compute Engine API.

The template is written using the Jinja templating language. When writing Deployment Manager templates, you can either use Jinja or Python. Jinja has the advantage of being more declarative, which can be more readable and easier to understand than Python. For some complex deployments, the full expressiveness of Python might make things simpler. In this case, Jinja is sufficient to create the necessary resources.

In a template, certain environment variables are automatically set, and you can access these variables by using the env dictionary. In this case, the name of the deployment is referenced as a name to be reused when assigning names to the resources that are created. For more information about available environment variables, see Using environment variables in the Deployment Manager documentation:

{% set NAME = "bookshelf-" + env["deployment"] %}
{% set SERVICE = "bookshelf-" + env["deployment"] + "-frontend" %}

The template uses the same startup script that is used in the Compute Engine tutorial. The script's content is inserted into the template, and the Jinja indent directive indents the content correctly:

            value: |
{{imports['startup-script']|indent(14, true)}}

In a Deployment Manager Jinja template, you can also refer to resources created elsewhere in the template. In the following example, the backend service uses the reference of the managed instance group to obtain the instance group it should point to:

- group: $(ref.{{ NAME }}-frontend-group.instanceGroup)
  zone: {{ properties['zone'] }}

Properties specified in config.yaml can be used in the template:

minNumReplicas: {{ properties['min-instances'] }}
maxNumReplicas: {{ properties['max-instances'] }}
  utilizationTarget: {{ properties['target-utilization'] }}

Cleaning up

To avoid incurring charges to your Google Cloud Platform account for the resources used in this tutorial:

Delete the project

The easiest way to eliminate billing is to delete the project that you created for the tutorial.

To delete the project:

  1. GCP Console에서 프로젝트 페이지로 이동합니다.

    프로젝트 페이지로 이동

  2. 프로젝트 목록에서 삭제할 프로젝트를 선택하고 삭제를 클릭합니다.
  3. 대화상자에서 프로젝트 ID를 입력한 다음 종료를 클릭하여 프로젝트를 삭제합니다.

Delete your deployment

To delete your deployment, enter the following command. This command deletes the load balancer and any Compute Engine instances that are associated with your deployment:

gcloud deployment-manager deployments delete my-deployment

What's next

이 페이지가 도움이 되었나요? 평가를 부탁드립니다.

다음에 대한 의견 보내기...