Python 2 is no longer supported by the community. We recommend that you migrate Python 2 apps to Python 3.

Deploying a Python App

Deploy your app to upload and run it on App Engine. When you deploy your apps, you create versions of those apps and their corresponding services in App Engine. You can deploy entire apps, including all the source code and configuration files, or you can deploy and update individual versions or configuration files.

To programmatically deploy your apps, use the Admin API.

If you use the deprecated appcfg tool to deploy apps, see appcfg reference for information on using the tool.

Before you begin

Before you can deploy your app:

  • The Owner of the Cloud project must create the App Engine application.

  • Ensure that your user account includes the required privileges.

  • Give Cloud Build permission to deploy apps in your project. When you deploy your app, App Engine uses Cloud Build to build the app into a container and deploy the container to the runtime. Cloud Build does not have permission to deploy Python 2 apps by default, so you need to give permission before you can deploy apps.

Installing the gcloud command line tool

To deploy your app with the gcloud tool, you must download, install, and initialize the Cloud SDK.

Download the SDK

If you already have the gcloud tool installed and want to configure it to use a Cloud project ID other than the one that you initialized it to, see Managing Cloud SDK Configurations.

Using a proxy

If you are running the deployment command from a system which uses an HTTP or HTTPS proxy, you must configure the tool so that it can communicate via the proxy.

Run the following commands to configure the gcloud tool:

gcloud config set proxy/type [PROXY_TYPE]
gcloud config set proxy/address [PROXY_ADDRESS]
gcloud config set proxy/port [PROXY_PORT]

You can also set a username and password for the proxy. For more information, see gcloud config.

Deploying an app

To deploy your app to App Engine, use the gcloud app deploy command from where your configuration files are located, for example app.yaml.

Choosing unique version IDs

For manually-scaled instances, the ID of your version should begin with a letter to distinguish them from numeric instance IDs. This ensures that requests are routed to the correct destination and avoids the ambiguity with URL patterns like 123-dot-my-service.[REGION_ID].r.appspot.com, which can be interpreted two ways:

  • If version 123 exists, the request is routed to version 123 of the my-service service.
  • If version 123 does not exist, the request is instead routed to instance ID 123 where the versions of the my-service service are running.

You can name your versions however you like for instances that are configured for auto scaling or basic scaling because targeting those instances is not supported. 

gcloud app deploy [CONFIGURATION_FILES]

By default, the command deploys the app.yaml configuration file from the current directory. If you're running the command from a directory that does not contain you app's app.yaml, or if you want to deploy multiple apps, replace [CONFIGURATION_FILES] with the path to one or more configuration files. Use a single white space to separate pathnames.

Optional flags:

  • --version: Specifies a custom version ID. By default, App Engine generates a version ID.
  • --no-promote: Deploys your app without automatically routing all traffic to that version. By default, each version that you deploy is automatically configured to receive 100% of traffic.
  • --project: Specifies an alternate Cloud project ID to what you initialized as the default in the gcloud tool.

For more information, see the gcloud app deploy reference or run gcloud help from the command line.

Examples:

gcloud app deploy
gcloud app deploy app.yaml dos.yaml index.yaml
gcloud app deploy --version [YOUR_VERSION_ID] --no-promote --project [YOUR_PROJECT_ID]

If you deploy a version that specifies the same version ID as a version that already exists on App Engine, the files that you deploy will overwrite the existing version. This can be problematic if the version is serving traffic because traffic to your application might be disrupted. You can avoid disrupting traffic if you deploy your new version with a different version ID and then move traffic to that version.

Deploying multiple service applications

When your application is factored into multiple services, you can deploy and update individually targeted services or all the services simultaneously. Deploying updates to services can include updating individual configuration files or updating the source code in the corresponding versions.

For example, you can deploy and create two versions in App Engine, where each version runs in their own service. The first version serves as the frontend service and the other as the backend of your app. You can then deploy individual configuration files to update only the settings of a service. You can also choose to deploy a new version to a service in order to update the source code of the frontend, backend, or both simultaneously.

Requirements for multiple services

You use the same deployment commands for deploying and updating the multiple services of your application with the following requirements:

  • You must initially deploy a version of your app to the default service before you can create and deploy subsequent services.

  • You must specify the ID of your service in the app.yaml configuration file of the corresponding version. To specify the service ID, you include the service: [YOUR_SERVICE_ID] element definition in each configuration file. By default, excluding this element definition from your configuration file deploys the version to the default service.

  • You must specify all the corresponding app.yaml configuration files in your deployment command to simultaneously deploy multiple services.

To deploy multiple services

From the root directory of the application where the configuration files are located, you run the deployment command and specify the relative paths and file names for each service's app.yaml file.

gcloud app deploy [CONFIGURATION_FILES]

Where [CONFIGURATION_FILES] is one or more configuration file's path and name separated by a single whitespace.

Example
gcloud app deploy main/app.yaml service1/app.yaml service2/app.yaml

You will receive verification via the command line as each service is successfully deployed.

Updating indexes

To create or update the indexes that your apps use, upload the index.yaml configuration file to Datastore. Indexes that don't exist yet are created after that configuration file is uploaded.

It can take a while for Datastore to create all the indexes and therefore, those indexes won't be immediately available to App Engine. If your app is already configured to receive traffic, then exceptions can occur for queries that require an index which is still in the process of being built.

To avoid exceptions, you must allow time for all the indexes to build, for example:

  • Upload the index.yaml configuration file to Datastore before you deploy your version:

    1. Upload the index.yaml file to Datastore:

        <pre class="prettyprint lang-sh">gcloud datastore indexes create index.yaml</pre>
  For information, see the <a
  href="/sdk/gcloud/reference/datastore/"><code>gcloud
  datastore</code> reference</a>.

    2. Use the Cloud Console to monitor the status of all your indexes:

      Go to the Datastore page

    3. After all your indexes are built, deploy the new version to App Engine.

  • Build your indexes before migrating or splitting traffic to your version:

    1. Deploy the new version without routing traffic to that version: You must specify both the app.yaml and index.yaml files and also include the --no-promote flag so that no traffic is routed to the version: 
      gcloud app deploy app.yaml index.yaml --no-promote
    2. Use the Cloud Console to monitor the status of all your indexes:

      Go to the Datastore page

    3. After all your indexes are built, use the Cloud Console to migrate or split traffic to your version:

      Go to the Versions page

For more information about indexes, see Configuring Datastore Indexes.

Troubleshooting

The following are common error messages that you might encounter:

PERMISSION_DENIED: Operation not allowed
The "appengine.applications.create" permission is required.
If the Cloud project does not include the required App Engine application, the gcloud app deploy command can fail when it tries to run the gcloud app create command. Only accounts with Owner role have the necessary permissions to create App Engine applications.
Command not found
If you did not create symlinks for the dev_appserver.sh tools when you installed the (deprecated) App Engine SDK, you might need to specify the full directory path to run the tool, for example: [PATH_TO_CLOUD_SDK]/bin/dev_appserver.py.
Import Error
If you installed both the Cloud SDK as well as the original App Engine SDK, the entries to your PATH might conflict with one another and cause import errors. If you received errors when running Cloud SDK commands, try explicitly using the original App Engine SDK. You can move the entry for the original App Engine SDK to earlier in your PATH so that those commands have priority. Alternatively, you can run the command by specifying the full directory path: [PATH_TO_APP_ENGINE_SDK]/dev_appserver.py.
[400] The first service (module) you upload to a new application must be the 'default' service (module)
Before you can deploy and create the multiple services of your application, you must first deploy and create the default service. For details about how to deploy a version to the default service, see Deploying multiple service applications.
Too Many Versions (403)
App Engine has a limit on the number of deployed versions of your application. These differ for free applications and deployed applications. You can use the Cloud Console to delete an older version and then upload your latest code.
Other deployment error
If your deployment fails, make sure the Cloud Build API is enabled in your project. App Engine enables this API automatically the first time you deploy an app, but if someone has since disabled the API, deployments will fail.

What's next