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.
Before you begin
Before you can deploy your app:
The Owner of the Google 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 in the app's region. Cloud Build does not have permission to deploy Java 8 apps by default, so you need to give permission before you can deploy apps.
Setting up the Maven build tool (recommended)
To deploy your app using the Maven build tool, you must set up your project to use the Maven plugin for App Engine.
- Install the gcloud CLI, the
app-engine-java
component, and log in. - Compile and build your project using the Maven plugin
Installing the gcloud CLI
To deploy your app with the gcloud CLI, you must download, install, and initialize the gcloud CLI.
If you already have the gcloud CLI installed and want to configure it to use a Google Cloud project ID other than the one that you initialized it to, see Managing gcloud CLI 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 CLI:
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
either the Maven build tool (recommended) or
the gcloud app deploy
command
from within the root directory of your
application.
Using Maven (recommended)
To deploy your app with the Maven build tool, run the following command from
your project's top level directory, where the pom.xml
file is located:
mvn package appengine:deploy -Dapp.deploy.projectId=PROJECT_ID
Replace PROJECT_ID with the ID of your Google Cloud project. If
your pom.xml
file already
specifies your
project ID, you don't need to include the -Dapp.deploy.projectId
property in the
command you run.
Using gcloud command line
gcloud app deploy [CONFIGURATION_FILES]
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. If you don't specify a version ID, App Engine generates one.--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 Google Cloud project ID to what you initialized as the default in the gcloud CLI.
For more information, see the gcloud app deploy
reference
or run gcloud help
from the command line.
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 like123-dot-my-service.[REGION_ID].r.appspot.com
, which can be interpreted
two ways:
- If version
123
exists, the request is routed to version123
of themy-service
service. - If version
123
does not exist, the request is instead routed to instance ID123
where the versions of themy-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.
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
appengine-web.xml
configuration file of the corresponding version. To specify the service ID, you include themodule: [YOUR_SERVICE_ID]
element definition in each configuration file. By default, excluding this element definition from your configuration file deploys the version to thedefault
service.You must specify all the corresponding
appengine-web.xml
configuration files in your deployment command to simultaneously deploy multiple services. Thedefault
service must be listed first.
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 appengine-web.xml
file.
Using the Maven build tool
If the root directory of your project contains only your services, you can deploy all those services with a single Maven command.
The Maven deployment command iterates through each of your project's services to locate their configuration files and then deploy each service.
To deploy multiple services using the Maven plugin:
- Ensure that appengine-maven-plugin has been added to your parent
pom.xml
file. Run the following command:
mvn package appengine:deploy -Dapp.deploy.projectId=PROJECT_ID
Replace PROJECT_ID with the ID of your Google Cloud project. If your
pom.xml
file already specifies your project ID, you don't need to include the-Dapp.deploy.projectId
property in the command you run.
Using gcloud
gcloud app deploy [CONFIGURATION_FILES]
Replace [CONFIGURATION_FILES]
with the path to one or more configuration files.
Use a single white space to separate pathnames.
You will receive verification via the command line as each service is successfully deployed.
Viewing build logs
Cloud Build streams build and deploy logs that are viewable in the Cloud Build history section of the Google Cloud console. To view builds in the app's region, use the Region drop-down menu at the top of the page to choose the region you would like to filter by.
Updating indexes
To create or update the indexes that your apps use, upload the
datastore-indexes.xml
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.xml
configuration file to Datastore before you deploy your version:Upload the
index.xml
file to Datastore:gcloud datastore indexes create index.yaml
For information, see thegcloud datastore
reference.Use the Google Cloud console to monitor the status of all your indexes:
After all your indexes are built, deploy the new version to App Engine.
Build your indexes before migrating or splitting traffic to your version:
-
Define a new version ID in your app's
appengine-web.xml
file. - Deploy the new version.
- Use the Google Cloud console to monitor the status of all your indexes:
- After all your indexes are built, use the Google Cloud console to migrate or split traffic to your version:
-
Define a new version ID in your app's
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 Google Cloud project does not include the required
App Engine
application, the
gcloud app deploy
command can fail when it tries to run thegcloud app create
command. Only accounts with Owner role have the necessary permissions to create App Engine applications. Command not found
- See Using local development server for instructions on how to set up the local development server tool.
Import Error
- If you installed both the gcloud CLI 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 gcloud CLI commands, follow the instructions for running the local development server.
[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 thedefault
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 Google Cloud console
to delete an older version and then upload your latest code.
You do not have permission to modify this app (403)
- This can occur when the account that you are authenticated as does not have
permission to deploy to the application ID that is specified in your command
or in your
appengine-web.xml
. Check your application ID is accurate and matches the value of your Google Cloud console project ID. Next, check the project permissions in the console and verify that your account is listed with a sufficient permission level to allow for deploying apps. [13] An internal error occurred while creating a Cloud Storage bucket.
App Engine creates a default Cloud Storage multi-regional bucket on your behalf, on the same region where your application is created. This bucket is required to store the contents of your application. This error is returned when this bucket cannot be created, in the following scenarios:
The default App Engine service account is not present in your project. If your account was removed before 30 days elapsed since its deletion, you can restore it.
Your project is under an organization enforcing the
constraints/gcp.resourceLocations
policy, and the organization is not allowing the creation of resources on the same region where your App Engine was created. You will need to override the enforcedconstraints/gcp.resourceLocations
policy for your project, and allow the multi-region locations on the same region where your App Engine app is created.
[13] An internal error occurred
This error can occur if the App Engine's
app.yaml
configuration file contains an invalid resourcename
under thevpc_access_connector
key. Make sure that thename
field contains the correct project and region where your Serverless VPC Access connector is created.If the issue persists after ensuring your
app.yaml
configuration is valid, use the Google Cloud SDK to re-deploy your service, adding the--verbosity=debug
flag, and contact Cloud Support by providing the command's output.- 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
- Use services to build a large application.
- Split traffic or migrate traffic to route traffic to the versions you deploy.
- Review the
gcloud app deploy
command line arguments and flags.