O Java 8 atingiu o fim do apoio técnico e vai ser descontinuado a 31 de janeiro de 2026. Após a descontinuação, não vai poder implementar aplicações Java 8, mesmo que a sua organização tenha usado anteriormente uma política da organização para reativar as implementações de runtimes antigos. As suas aplicações Java 8 existentes vão continuar a ser executadas e a receber tráfego após a data de descontinuação. Recomendamos que migre para a versão suportada mais recente do Java.

Esta página foi traduzida pela API Cloud Translation.

Migração para o plugin do Gradle baseado na CLI gcloud

Se usou anteriormente o plug-in baseado no SDK do App Engine Java (com.google.appengine.appengine-gradle) e quiser mudar para a nova CLI do Google Cloud, migre para o plug-in baseado na CLI gcloud (com.google.cloud.tools.appengine-gradle).

Vantagens do plug-in baseado na CLI gcloud

A atualização para o novo plug-in oferece as seguintes vantagens:

Usa as mesmas credenciais de autenticação que todos os outros comandos baseados na CLI gcloud, que são produzidas a partir do fluxo padrão.gcloud auth login
Suporta o ambiente flexível do App Engine.
Atualiza automaticamente o servidor de desenvolvimento local como parte do fluxo de atualização padrão da CLI gcloud.
Suporta a implementação de configurações do serviço App Engine (cron, filas, dos, dispatch), independentemente do seu serviço.

Diferenças notáveis

Antes de migrar, tenha em atenção estas diferenças importantes:

Dependência da CLI gcloud: O plug-in antigo é executado sem dependências específicas do ambiente local, além do Java, mas o novo plug-in requer que tenha a CLI gcloud instalada.
Nenhuma geração de documento de descoberta de pontos finais: O novo plug-in não gera documentos de descoberta de pontos finais, uma funcionalidade disponível num plug-in separado. A execução do back-end dos Endpoints já não requer a geração deste ficheiro num passo de compilação, uma vez que o servidor agora o gera no tempo de execução. Só deve usar o novo plug-in se precisar de gerar bibliotecas de cliente, como para iOS ou Android. Saiba mais sobre os novos plug-ins revendo o guia Migrar para frameworks de pontos finais para o App Engine.
O formato de ficheiro EAR já não é suportado: O novo plug-in já não suporta o formato de ficheiro EAR para executar e implementar vários serviços em simultâneo.
Novo comando de implementação: O plug-in antigo chama o comando appcfg para implementar aplicações, enquanto o novo plug-in implementa usando a nova CLI gcloud.
A melhoria do Datanucleus JPA/JDO tem de ser configurada manualmente: Se o seu projeto usar o melhoramento JPA/JDO Datanucleus, tem de configurar manualmente o melhoramento Datanucleus depois de mudar para o plug-in baseado na CLI gcloud.gradle-appengine-plugin Veja um exemplo do Stackoverflow.
O Android Studio não é suportado: Pode mudar o seu projeto do Android Studio para usar o novo plug-in, mas o servidor de desenvolvimento do App Engine do Android Studio e o suporte de implementação não funcionam com este novo plug-in. Para executar e implementar a sua app, tem de invocar o Gradle diretamente.

A utilização de ficheiros de configuração XML é suportada, mas não a de ficheiros YAML.

Migrar para o novo plugin

Remova a configuração e as importações gradle-appengine-pluginbuild.gradle antigas do ficheiro.

Adicione o novo plugin à secção classpath do ficheiro build.gradlebuildscript:

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath 'com.google.cloud.tools:appengine-gradle-plugin:2.0.1'
    }
}

Na raiz do seu serviço, execute o seguinte comando para verificar se consegue executar a sua app localmente:
```
gradle appengineRun
```
Na secção buildscript do ficheiro build.gradle, configure a implementação especificando o ID do projeto e a versão:
```
appengine {
    deploy {
        version = 'v1'
        project = "your GCP project ID"
    }
}
```
As novas ferramentas ignoram os elementos de aplicação e versão no seu ficheiro appengine-web.xml.
Na raiz do seu serviço, execute o seguinte comando para verificar se consegue implementar a sua aplicação:
```
gradle appengineDeploy
```

Migrar configurações de vários serviços baseadas em EAR

O novo plug-in não suporta a criação de pacotes EAR. Em alternativa, suporta a execução de vários serviços localmente sem passos de embalagem especiais.

Para migrar o seu projeto do Gradle baseado em EAR:

Escolha um serviço principal que seja responsável pela execução dos restantes serviços. Deve selecionar o seu serviço predefinido, mas pode ser qualquer um dos serviços executados em conjunto.

Na configuração do appengine, modifique a entrada run.services para incluir todos os serviços que devem ser executados pelo servidor de desenvolvimento local.

Exemplo de estrutura de projeto:

../{projectRoot}/
  build.gradle
  settings.gradle (includes default-service & secondary-service)
       {your-default-service}/build.gradle {includes appengine-gradle-plugin}
          ….
       {your-default-service}/src/main/webapp/WEB-INF/appengine-web.xml
       {your-secondary-service}build.gradle {includes appengine-gradle-plugin}
          ….
       {your-secondary-service}/src/main/webapp/WEB-INF/appengine-web.xml

Um exemplo de build.gradle buildscript:

appengine {
    run {
        // configure the app to point to the right service directories
        services = [
                projectAsService(project),
                projectAsService(":another-module")
        ]
    }
}

// helper method to obtain correct directory and set up dependencies
def getExplodedAppDir(Project serverProject) {
    // if not 'this' module, then do some setup.
    if (serverProject != project) {
        // make sure we evaluate other modules first so we get the right value
        evaluationDependsOn(serverProject.path)
        // make sure we build "run" depends on the other modules exploding wars
        project.tasks.appengineRun.dependsOn serverProject.tasks.explodeWar
    }
    return serverProject.tasks.explodeWar.explodedAppDirectory
}

Comandos Gradle baseados no SDK do App Engine vs. comandos baseados na CLI gcloud

A tabela seguinte mostra as diferentes formas de invocar o plugin do Gradle, consoante use o plugin do Gradle baseado no SDK do App Engine ou o plugin do Gradle baseado na CLI gcloud.

Ação	Baseado no SDK do App Engine	Baseado na CLI gcloud
Execute a app localmente	`appengine:devserver`	`appengineRun`
Implementar uma nova app, versão ou serviço.	`appengine:update`	`appengineDeploy`
Definir a versão predefinida da aplicação.	`appengine:set_default_version`	gcloud app services set-traffic ou gcloud app versions migrate
Atualize as tarefas cron da aplicação.	`appengine:update_cron`	`appengineDeployCron`
Atualize a configuração de envio da aplicação.	`appengine:update_dispatch`	`appengineDeployDispatch`
Atualize a configuração da proteção contra DoS de aplicações.	`appengine:update_dos`	`appengineDeployDos`
Atualize as definições da fila de tarefas da aplicação.	`appengine:update_queues`	`appengineDeployQueue`
Atualize os índices do armazenamento de dados.	`appengine:update_indexes`	`appengineDeployIndex`
Elimine índices não usados da aplicação.	`appengine:vacuum_indexes`	gcloud datastore indexes cleanup
Inicie a versão do módulo especificada.	`appengine:start_module_version`	gcloud app versions start
Pare a versão do módulo especificada.	`appengine:stop_module_version`	gcloud app versions stop
Reverter uma atualização em curso.	`appengine:rollback`	gcloud app versions start, gcloud app versions stop

O que se segue?

Agora que migrou com êxito para o novo plug-in, pode testar e implementar a sua aplicação.

Migração para o plugin do Gradle baseado na CLI gcloud Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.