Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Utilizzo di Apache Maven e del plug-in App Engine (basato su Google Cloud CLI)

Questa pagina spiega come gestire un progetto App Engine per l'API Cloud Endpoints Frameworks utilizzando Apache Maven. Apache Maven è uno strumento di gestione e comprensione dei progetti software in grado di creare file WAR (Web Application Archive) per il deployment in App Engine. Google fornisce un plug-in e archetipi Maven supportati da Maven 3.3.9 o versioni successive.

Maven scarica le librerie Java dall'SDK App Engine. Puoi utilizzare Maven per testare l'app localmente ed eseguirne il deployment in App Engine.

Prima di iniziare

Utilizzail Google Cloud console per creare e configurare il tuo Google Cloud progetto:

Vai ad App Engine
1. Seleziona o crea un nuovo Google Cloud progetto.
2. Se devi creare un'applicazione App Engine per il tuo progetto, segui le istruzioni per selezionare la regione in cui vuoi collocare l'applicazione App Engine.
Scarica e installa gcloud CLI, quindi inizializza la Google Cloud CLI.
Se hai già installato Google Cloud CLI e vuoi configurarlo in modo che utilizzi un ID progetto diverso da quello con cui l'hai inizializzato, consulta Gestire le configurazioni di gcloud CLI. Google Cloud
Installa il componente app-engine-java di gcloud CLI:
```
gcloud components install app-engine-java
```
Nota: per assicurarti di avere l'ultima versione di gcloud CLI per Java, esegui gcloud components update.
Se non hai Java, scaricalo, installalo e configurarlo.

Imposta i flag del compilatore Java nel file pom.xml del progetto per specificare il bytecode Java 8:

<properties>
  <maven.compiler.source>1.8</maven.compiler.source>
  <maven.compiler.target>1.8</maven.compiler.target>
</properties>

Devi aver installato Apache Maven versione 3.3.9 o successive. Per determinare la versione di Maven, esegui il seguente comando:
```
 mvn -v
```
Se non hai installato la versione corretta di Maven:
1. Scarica Maven versione 3.3.9 o successive dal sito web di Maven.
2. Installa Maven sulla tua macchina locale.
  Nota: gli utenti Linux potrebbero dover scaricare Maven anziché utilizzare apt-get install.

Aggiungere il plug-in Maven per App Engine a un progetto esistente (facoltativo)

Per utilizzare il plug-in Maven per App Engine in un progetto Maven esistente, aggiungi quanto segue alla plugins sezione del file pom.xml del progetto:

<plugin>
   <groupId>com.google.cloud.tools</groupId>
   <artifactId>appengine-maven-plugin</artifactId>
   <version>2.8.1</version>
</plugin>

Scegliere un archetipo App Engine

Gli archetipi Maven consentono agli utenti di creare progetti Maven utilizzando modelli che coprono scenari comuni. App Engine sfrutta questa funzionalità di Maven per fornire alcuni archetipi App Engine utili in Maven Central. Seleziona un archetipo App Engine appropriato per la tua app:

Tipo di applicazione	Artefatto	Descrizione
Endpoints Frameworks per App Engine	`endpoints-skeleton-archetype`	Genera un nuovo progetto API di backend Endpoints Frameworks per App Engine vuoto, pronto per le tue classi e risorse, con file e directory obbligatori.
Endpoints Frameworks per App Engine	`hello-endpoints-archetype`	Genera un progetto API di backend Endpoints Frameworks per App Engine di base, pronto per la creazione e l'esecuzione.

Creare un nuovo progetto utilizzando Maven

Durante la creazione del progetto, Maven ti chiede di fornire groupId, artifactId, version e package per il progetto.

Termine	Significato
`groupId`	Uno spazio dei nomi all'interno di Maven per tenere traccia degli artefatti. Quando gli utenti utilizzano il tuo progetto nel proprio progetto Maven, funge da attributo della dipendenza che finiscono per specificare.
`artifactId`	Il nome del tuo progetto in Maven. Viene specificato anche dagli utenti del tuo progetto quando dipendono da te nei propri progetti Maven.
`version`	La versione iniziale di Maven con cui vuoi generare il progetto. È consigliabile aggiungere il suffisso `-SNAPSHOT` a `version`, perché in questo modo il plug-in di release Maven supporta le versioni in fase di sviluppo. Per ulteriori informazioni, consulta la guida di Maven all'utilizzo del plug-in di release.
`package`	Il pacchetto Java creato durante la generazione.

Creare una nuova app Endpoints Frameworks

Questa sezione descrive la creazione di un nuovo progetto Endpoints Frameworks versione 2.0.

Il hello-endpoints-archetype fornisce un esempio di utilizzo dei plug-in, inclusi il plug-in Maven per App Engine e il plug-in Maven per Endpoints Frameworks.

hello-endpoints-archetype genera un'API Greetings di esempio utilizzando Endpoints Frameworks versione 2.0. Funge anche da esempio per la migrazione delle applicazioni Endpoints Frameworks versione 1.0 a Endpoints Frameworks versione 2.0.

Il file README.md generato con l'archetipo fornisce informazioni su dove è avvenuta la migrazione.

Per creare un progetto di archetipo API di backend Endpoints Frameworks per App Engine:

Modifica la directory con quella in cui vuoi creare il progetto.
Esegui il seguente comando Maven:
```
mvn archetype:generate -Dgoogle-cloud-project=[YOUR-PROJECT-ID] -Dappengine-plugin=2.8.1 -Dendpoints-frameworks=2.1.0 -Dendpoints-plugin=1.0.2 -Dappengine-sdk=1.9.98 -Dfilter=com.google.appengine.archetypes:
```
Dove:
- -Dgoogle-cloud-project è impostato sull'ID progetto.
- -Dappengine-plugin è impostato sulla versione più recente del plug-in Maven per App Engine.
- -Dendpoints-frameworks è impostato sulla versione più recente di Endpoints Frameworks per App Engine per le dipendenze Maven.
- -Dendpoints-plugin è impostato sulla versione più recente del plug-in Maven per Endpoints Frameworks per App Engine.
Nota: gli archetipi Endpoints Frameworks per App Engine supportano Gradle e utilizzano la versione più recente di ogni dipendenza.
Fornisci il numero corrispondente a hello-endpoints-archetype.

Nota: per creare un progetto vuoto contenente la struttura di directory e i file richiesti pronti per le tue classi, fornisci il numero corrispondente a endpoints-skeleton-archetype.
Seleziona la versione più recente dall'elenco visualizzato delle versioni dell'archetipo disponibili.
Quando ti viene chiesto di Define value for property 'groupId', fornisci lo spazio dei nomi per la tua app, ad esempio il valore com.example.helloendpoints.
Quando ti viene chiesto di Define value for property 'artifactId', fornisci il nome del progetto, ad esempio il valore helloendpoints.
Quando ti viene chiesto di Define value for property 'version', accetta il valore predefinito.
Quando ti viene chiesto di Define value for property 'package', accetta il valore predefinito.
Quando ti viene chiesto di confermare le tue scelte, accetta il valore predefinito inserendo Y.
Attendi il completamento della generazione del progetto. Quindi, modifica le directory con la nuova directory del progetto, ad esempio helloendpoints/.
Crea il progetto.
```
mvn clean package
```

Attendi la creazione del progetto. Al termine del progetto, viene visualizzato un messaggio simile al seguente:

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 4.062 s
[INFO] Finished at: 2017-02-28T00:28:03-08:00
[INFO] Final Memory: 27M/485M
[INFO] ------------------------------------------------------------------------

Per testare localmente ed eseguire il deployment del progetto nell'ambiente standard di App Engine , consulta Gestire, testare ed eseguire il deployment di un progetto Maven.
Inoltre, puoi generare librerie client Java per l'API Greeting utilizzando il plug-in Maven per Endpoints Frameworks:
```
mvn endpoints-framework:clientLibs
```

Il seguente diagramma mostra il layout di base del progetto dell'API Greetings:

Layout del progetto Maven

README.md contiene informazioni sull'esempio generato.
Greetings.java contiene una definizione API per un'API Greetings di esempio.
Constants.java contiene le costanti utilizzate dall'API Greetings di esempio.
HelloGreeting.java contiene un container per i messaggi ricevuti e inviati dall'API Greetings di esempio.
index.html contiene una semplice UI per chiamare l'API Greetings di backend.
base.js contiene il codice JavaScript necessario per l'UI per effettuare richieste di backend.
build.gradle una volta generato, l'esempio supporta anche Gradle e ulteriori informazioni su questa funzionalità in README.md.

Compilare e creare l'applicazione

Per creare un'applicazione creata con gli archetipi Maven per App Engine:

Passa alla directory principale del progetto, ad esempio guestbook/.
Esegui Maven:
```
mvn clean package
```

Attendi la creazione del progetto. Al termine del progetto, viene visualizzato un messaggio simile al seguente:

BUILD SUCCESS
 Total time: 10.724s
 Finished at: 2016-08-04T16:18:24-07:00
 Final Memory: 24M/213M

Testare l'applicazione con il server di sviluppo

Durante la fase di sviluppo, puoi eseguire e testare l'applicazione in qualsiasi momento nel server di sviluppo eseguendo il plug-in Maven per App Engine.

Per testare l'app Endpoints Frameworks per App Engine:

Se non l'hai ancora fatto, crea l'app:
```
mvn clean package
```

Esegui l'esempio localmente:

mvn appengine:run

Attendi l'avvio del server. Quando il server è completamente avviato con l'applicazione in esecuzione, viene visualizzato un messaggio simile al seguente:

[INFO] GCLOUD: INFO ### devappserver2.py:764] Skipping SDK update check.
[INFO] GCLOUD: INFO ### api_server.py:268] Starting API server at: http://localhost:34199
[INFO] GCLOUD: INFO ### dispatcher.py:199] Starting module "default" running at: http://localhost:8080
[INFO] GCLOUD: INFO ### admin_server.py:116] Starting admin server at: http://localhost:8000
[INFO] GCLOUD: ### com.google.appengine.tools.development.SystemPropertiesManager setSystemProperties

Utilizza il browser per accedere all'indirizzo http://localhost:8080/ per accedere all'app.
Arresta l'applicazione e il server di sviluppo premendo Control+C.

Specificare una porta per i test locali

Quando esegui l'applicazione nel server di sviluppo locale, la porta predefinita è 8080. Puoi modificare questa impostazione predefinita modificando la voce del plug-in per appengine-maven-plugin. Ad esempio, puoi specificare la porta e l'indirizzo nel file pom.xml della directory dell'applicazione:

<plugins>
   <plugin>
     <groupId>com.google.cloud.tools</groupId>
     <artifactId>appengine-maven-plugin</artifactId>
     <version>2.8.1</version>
     <configuration>
       <devserver.host>0.0.0.0</devserver.host>
       <devserver.port>8181</devserver.port>
     </configuration>
  </plugin>
</plugins>

In questo esempio, <devserver.port> imposta la porta su 8181 anziché sul valore predefinito e viene specificato l'indirizzo 0.0.0.0, il che significa che il server di sviluppo è in ascolto delle richieste provenienti dalla rete locale.

Il prefisso devserver è facoltativo; in alternativa, puoi utilizzare <port>8181</port> invece.

Eseguire il debug sul server di sviluppo

Per eseguire il debug di un'applicazione in esecuzione localmente, imposta jvmFlags nella configurazione del plug-in per abilitare il debug sulla JVM sottostante, ad esempio:

<configuration>
  <jvmFlags>
    <jvmFlag>-Xdebug</jvmFlag>
    <jvmFlag>-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005</jvmFlag>
  </jvmFlags>
</configuration>

Eseguire il deployment dell'applicazione

Per eseguire il deployment dell'applicazione:

mvn appengine:deploy

L'obiettivo appengine:deploy e tutti gli altri obiettivi del plug-in Maven per App Engine hanno parametri associati che puoi utilizzare. Per un elenco completo di obiettivi e parametri, consulta Obiettivi e parametri del plug-in Maven per App Engine.

Passaggi successivi

Esplora il codice del plug-in Maven per App Engine e segnala i problemi su GitHub.
Scopri come specificare i parametri per gli obiettivi consultando Obiettivi e parametri di Maven per App Engine.
Esplora il codice del plug-in Maven per Endpoints Frameworks e segnala i problemi su GitHub.
Scopri come specificare i parametri per gli obiettivi consultando Plug-in Maven per Cloud Endpoints Frameworks.