Vuelve a empaquetar un archivo WAR en un archivo JAR

Si migras a la versión más reciente compatible de Java y tu aplicación no usa los servicios empaquetados heredados, debes volver a empaquetar tu aplicación web de Java 8 de App Engine en un archivo JAR ejecutable.

Tu aplicación debe tener una clase Main que inicie un servidor web que responda a las solicitudes HTTP en el puerto especificado por la variable del entorno PORT, por lo general, 8081.

Por ejemplo:

import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;

public class Main {

  public static void main(String[] args) throws IOException {
    // Create an instance of HttpServer bound to port defined by the 
    // PORT environment variable when present, otherwise on 8080.
    int port = Integer.parseInt(System.getenv().getOrDefault("PORT", "8080"));
    HttpServer server = HttpServer.create(new InetSocketAddress(port), 0);

    // Set root URI path.
    server.createContext("/", (var t) -> {
      byte[] response = "Hello World from Google App Engine Java 11.".getBytes();
      t.sendResponseHeaders(200, response.length);
      try (OutputStream os = t.getResponseBody()) {
        os.write(response);
      }
    });

    // Start the server.
    server.start();
  }
}

Ejemplo de migración de WAR (Java 11)

En las siguientes instrucciones, se muestra cómo volver a empaquetar una aplicación hello-world de Java 8 de App Engine como un JAR para que se ejecute en el entorno de ejecución de Java 11.

La migración usa el artefacto appengine-simple-jetty-main. Esto proporciona una clase Main con un servidor web Jetty simple que carga un archivo WAR y empaqueta tu app en un archivo JAR ejecutable:

Clona el artefacto del servidor Jetty incorporado en tu máquina local:
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples
```
De manera opcional, puedes descargar la muestra como un archivo ZIP y extraerla.

Dirígete al directorio que contiene el código de muestra:

cd java-docs-samples/appengine-java11/appengine-simple-jetty-main/

Instala la dependencia de forma local:
```
mvn install
```

Agrega el siguiente código al archivo pom.xml de tu proyecto:

dependencia appengine-simple-jetty-main:

<dependency>
  <groupId>com.example.appengine</groupId>
  <artifactId>simple-jetty-main</artifactId>
  <version>1</version>
  <scope>provided</scope>
</dependency>

Complemento maven-dependency:

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-dependency-plugin</artifactId>
  <version>3.6.1</version>
  <executions>
    <execution>
      <id>copy</id>
      <phase>prepare-package</phase>
      <goals>
        <goal>copy-dependencies</goal>
      </goals>
      <configuration>
        <outputDirectory>
          ${project.build.directory}/appengine-staging
        </outputDirectory>
      </configuration>
    </execution>
  </executions>
</plugin>

App Engine implementa archivos ubicados en el directorio ${build.directory}/appengine-staging. Si agregas el complemento maven-dependency a tu compilación, App Engine instala las dependencias especificadas en la carpeta correcta.

Crea un elemento entrypoint en el archivo app.yaml para llamar al objeto appengine-simple-jetty-main y pasar el archivo WAR como argumento. Por ejemplo, consulta el archivo app.yaml de la muestra helloworld-servlet:
```
runtime: java11
entrypoint: 'java -cp "*" com.example.appengine.jetty.Main helloworld.war'
```
Para ejecutar tu aplicación de forma local, sigue estos pasos:
1. Empaqueta tu aplicación:
```
mvn clean package
```
2. Inicia el servidor con tu archivo WAR como argumento.
  
  Por ejemplo, puedes iniciar el servidor en la muestra helloworld-servlet si ejecutas el siguiente comando desde la carpeta java-docs-samples/appengine-java11/appengine-simple-jetty-main/:
```
mvn exec:java -Dexec.args="../helloworld-java8/target/helloworld.war"
```
3. En el navegador web, ingresa la siguiente dirección:
  
  http://localhost:8080
Para implementar tu aplicación, ejecuta el siguiente comando:
Herramientas de gcloud
```
gcloud app deploy
```
Complemento de Maven
```
mvn package appengine:deploy -Dapp.deploy.projectId=PROJECT_ID
```
Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud. Si tu archivo pom.xml ya especifica tu ID del proyecto, no necesitas incluir la propiedad -Dapp.deploy.projectId en el comando que ejecutas.

Vuelve a empaquetar un archivo WAR en un archivo JAR

Ejemplo de migración de WAR (Java 11)

Herramientas de gcloud

Complemento de Maven