Como implantar versões do seu aplicativo no App Engine

ID da região

O REGION_ID é um código abreviado que o Google atribui com base na região que você selecionou ao criar o aplicativo. O código não corresponde a um país ou estado, ainda que alguns IDs de região sejam semelhantes aos códigos de país e estado geralmente usados. Para apps criados após fevereiro de 2020, o REGION_ID.r está incluído nos URLs do App Engine. Para apps existentes criados antes dessa data, o ID da região é opcional no URL.

Saiba mais sobre IDs de região.

Use a API Admin do Google App Engine para implantar as versões dos seus aplicativos de maneira programática no aplicativo do App Engine por meio de solicitações HTTP POST.

Antes de começar

Antes de enviar a solicitação HTTP de implantação, é preciso autorizar a solicitação HTTP, acessar os arquivos preparados do seu aplicativo e ter um arquivo de configuração no formato JSON. Veja os tópicos a seguir para ajudá-lo com esses pré-requisitos:

Como implantar seu aplicativo no App Engine com a API Admin

Para implantar uma versão do seu aplicativo no aplicativo do App Engine, siga estas etapas:

Autorize suas solicitações HTTP, por exemplo, receba um token de acesso.

É possível autorizar o acesso à API Admin usando diferentes fluxos do OAuth, dependendo das necessidades do aplicativo de API. Para mais informações, consulte Como acessar a API.

Dica: se quiser usar tokens de acesso, receba-os imediatamente no OAuth 2.0 Playground.
Envie uma solicitação HTTP POST usando seu token de acesso e a API Admin para implantar sua versão no aplicativo do App Engine:

Para implantar uma versão, envie uma solicitação HTTP POST que especifique o arquivo de configuração JSON e defina um recurso Version do serviço de destino e do aplicativo App Engine.

Por exemplo, é possível usar a seguinte solicitação HTTP POST para implantar a versão especificada no arquivo de configuração JSON para o serviço default do aplicativo MY_PROJECT_ID:
```
POST https://appengine.googleapis.com/v1/apps/[MY_PROJECT_ID]/services/default/versions app.json
```
Importante: a primeira versão do aplicativo do App Engine precisa ser implantada inicialmente no serviço default. Para as versões implantadas posteriormente, o serviço definido é criado, se ele ainda não existir no seu aplicativo.

Exemplo de comando cURL:
```
curl -X POST -T "app.json" -H "Content-Type: application/json" -H "Authorization: Bearer [MY_ACCESS_TOKEN]" https://appengine.googleapis.com/v1/apps/[MY_PROJECT_ID]/services/default/versions
```
Em que:
- [MY_ACCESS_TOKEN] é o token de acesso que você recebeu para autorizar suas solicitações HTTP.
- [MY_PROJECT_ID] é o código do projeto em que você quer implantar a versão.
Exemplo de resposta:
```
{
  "metadata": {
    "@type": "type.googleapis.com/google.appengine.v1.OperationMetadataV1",
    "insertTime": "2015-05-29T17:12:44.679Z",
    "method": "google.appengine.v1.Versions.CreateVersion",
    "target": "apps/[MY_PROJECT_ID]/services/default/versions/v1",
    "user": "me@example.com"
  }
  "name": "apps/[MY_PROJECT_ID]/operations/89729825-ef1f-4ffa-b3e3-e2c25eb66a85"
}
```

Verifique se a versão foi implantada no seu aplicativo do App Engine:

Veja o status da operação de implantação efetiva:

A solicitação de HTTP POST usada na etapa anterior retornou o nome da operação no campo name, que você usa com o método GET da coleção apps.operations para verificar o status da operação de implantação.

Por exemplo, se o campo name da resposta for:

"name": "apps/[MY_PROJECT_ID]/operations/89729825-ef1f-4ffa-b3e3-e2c25eb66a85"

Você enviará a seguinte solicitação HTTP GET:

GET https://appengine.googleapis.com/v1/apps/[MY_PROJECT_ID]/operations/89729825-ef1f-4ffa-b3e3-e2c25eb66a85

Exemplo de comando cURL:

curl -H "Authorization: Bearer [MY_ACCESS_TOKEN]" https://appengine.googleapis.com/v1/apps/[MY_PROJECT_ID]/operations/89729825-ef1f-4ffa-b3e3-e2c25eb66a85

em que [MY_ACCESS_TOKEN] é o token de acesso e [MY_PROJECT_ID] é o código do projeto em que a versão foi implantada.

Exemplo de resposta:

{
  "done": true,
  "metadata": {
    "@type": "type.googleapis.com/google.appengine.v1.OperationMetadataV1",
    "endTime": "2015-05-29T17:13:20.424Z",
    "insertTime": "2015-05-29T17:12:44.679Z",
    "method": "google.appengine.v1.Versions.CreateVersion",
    "target": "apps/[MY_PROJECT_ID]/services/default/versions/v1",
    "user": "me@example.com"
  },
  "name": "apps/[MY_PROJECT_ID]/operations/89729825-ef1f-4ffa-b3e3-e2c25eb66a85",
  "response": {
    "@type": "type.googleapis.com/google.appengine.v1.Version",
    "creationTime": "2015-05-29T17:12:46.000Z",
    "deployer": "me@example.com",
    "id": "v1",
    "name": "apps/[MY_PROJECT_ID]/services/default/versions/v1",
    "runtime": "python27",
    "servingStatus": "SERVING",
    "threadsafe": true,
  }
}

Para saber mais sobre como pesquisar operações de longa duração, consulte a referência da RPC google.longrunning.

Verifique se a versão foi criada no aplicativo do App Engine:

Para visualizar detalhes sobre a versão, use o método GET da coleção apps.services.versions. Você precisa especificar a versão que você implantou na solicitação HTTP GET, por exemplo:

GET https://appengine.googleapis.com/v1/apps/[MY_PROJECT_ID]/services/default/versions/v1

Exemplo de comando cURL:

curl -H "Authorization: Bearer [MY_ACCESS_TOKEN]" https://appengine.googleapis.com/v1/apps/[MY_PROJECT_ID]/services/default/versions/v1

em que [MY_ACCESS_TOKEN] é o token de acesso e [MY_PROJECT_ID] é o código do projeto em que a versão foi implantada.

Exemplo de resposta:

{
  "creationTime": "2015-05-29T17:12:46.000Z",
  "deployer": "me@example.com",
  "deployment": {
    "files": {
      "my-python-app.py": {
        "sha1Sum": "7cffbdaa9fcfa46e5e58269bfe336dd815de0566",
        "sourceUrl": "https://storage.googleapis.com/[YOUR_BUCKET_ID]/my-application/logo.jpg",
      },
      "logo.jpg": {
        "sha1Sum": "13f7ea1e24f7cd2de5c66660525f2b509da37c14",
        "sourceUrl": "https://storage.googleapis.com/[YOUR_BUCKET_ID]/my-application/my-python-app.py"
      }
    }
  },
  "handlers": [
    {
      "authFailAction": "AUTH_FAIL_ACTION_REDIRECT",
      "login": "LOGIN_OPTIONAL",
      "script": {
        "scriptPath": "my-python-app.application",
      },
      "securityLevel": "SECURE_OPTIONAL",
      "urlRegex": "/.*"
    }
  ]
  "id": "v1",
  "name": "apps/[MY_PROJECT_ID]/services/default/versions/v1",
  "runtime": "python27",
  "servingStatus": "SERVING",
  "threadsafe": true,
}

GET https://appengine.googleapis.com/v1/apps/[MY_PROJECT_ID]/services/default/versions/v1?view=FULL

Opcional: para iniciar o navegador e visualizar o aplicativo em https://VERSION_ID-dot-default-dot-PROJECT_ID.REGION_ID.r.appspot.com, execute o comando a seguir:
```
gcloud app browse -v [MY_VERSION_ID]
```
Configure quanto tráfego a versão que você acabou de implantar precisa receber.

Por padrão, a versão inicial implantada no aplicativo do App Engine é configurada automaticamente para receber 100% do tráfego. No entanto, todas as versões implantadas posteriormente no mesmo aplicativo do App Engine precisam ser configuradas manualmente, caso contrário, não receberão tráfego.

Para ver detalhes sobre como configurar o tráfego para suas versões, consulte Como migrar e dividir o tráfego.

Como implantar outras versões e serviços

As etapas para implantar versões posteriores do aplicativo, incluindo a criação de outros serviços, são quase idênticas às etapas de implantação abordadas nesta tarefa. Para substituir a versão atual em execução no aplicativo do App Engine ou para incluir outros serviços, basta implantar novas versões depois de fazer algumas alterações nos arquivos de configuração.

Veja nos exemplos a seguir como implantar outras versões no aplicativo do App Engine. Lembre-se que é necessário configurar o tráfego das versões após implantá-las.

Exemplo: como implantar outras versões

Se uma versão antiga ou com falha estiver em execução no App Engine, basta substituí-la pela implantação de outra versão no aplicativo do App Engine e direcionar o tráfego para ela. Por exemplo, depois de modificar o código-fonte do app, é possível mudar o valor de version no arquivo app.yaml, crie um novo arquivo app.json e implante uma versão v2 do app com outra solicitação POST HTTP:

Exemplo de arquivo app.yaml atualizado:

  service: default
  version: v2
  runtime: python27
  threadsafe: true
  handlers:
  - url: /.*
    script: my-python-app.application

Exemplo da solicitação HTTP POST para a versão v2:

  POST https://appengine.googleapis.com/v1/apps/[MY_PROJECT_ID]/services/default/versions app.json

Depois de garantir que a implantação da versão tenha sido bem-sucedida, envie uma solicitação HTTP PATCH para direcionar todo o tráfego para a nova versão, por exemplo:

  PATCH https://appengine.googleapis.com/v1/apps/[MY_PROJECT_ID]/services/default/?updateMask=split {"split": { "allocations": { "v2": "1" } } }

Veja informações sobre como direcionar o tráfego em Como migrar e dividir o tráfego.

Exemplo: como implantar vários serviços

Se você tiver uma versão v1 em execução no seu aplicativo do App Engine e quiser implantar outro serviço, por exemplo, backend, execute as mesmas etapas de implantação.

Por exemplo, para implantar a versão v1 que cria o serviço backend:

Crie o novo código e os arquivos de origem para o serviço backend.
Prepare os recursos do aplicativo para seu serviço backend em um bucket do Cloud Storage.
Crie o arquivo de configuração backend/app.json.

Use solicitações HTTP para implantar a versão v1 do serviço backend no seu aplicativo do App Engine:

Exemplo de solicitação HTTP POST:

POST https://appengine.googleapis.com/v1/apps/[MY_PROJECT_ID]/services/backend/versions backend/app.json

Exemplo de solicitação HTTP GET para verificar se a versão v1 no serviço backend foi criada:

GET https://appengine.googleapis.com/v1/apps/[MY_PROJECT_ID]/services

Exemplo de resposta:

{
  "services": [
    {
      "name": "apps/[MY_PROJECT_ID]/services/default",
      "id": "default",
      "split": {
        "allocations": {
          "v2": 1
        }
      }
    },
    {
      "name": "apps/[MY_PROJECT_ID]/services/backend",
      "id": "backend",
      "split": {
        "allocations": {
          "v1": 1
        }
      }
    }
  ]
}

A seguir

Como migrar e dividir o tráfego