Questa pagina è stata tradotta dall'API Cloud Translation.

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 compilare 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

Utilizza la console Google Cloud per creare e configurare il tuo progetto Google Cloud:

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

Imposta i flag del compilatore Java in pom.xml del progetto per specificare il codice a byte 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 3.3.9 o versioni successive. Per determinare la versione di Maven, esegui il seguente comando:
```
 mvn -v
```
Se non hai installato la versione corretta di Maven:
1. Scarica la versione 3.3.9 o successiva di Maven 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.

Aggiunta del plug-in Maven App Engine a un progetto esistente (facoltativo)

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

<plugin>
   <groupId>com.google.cloud.tools</groupId>
   <artifactId>appengine-maven-plugin</artifactId>
   <version>2.7.0</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 utili archetipi App Engine su 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 Endpoints Frameworks per l'API backend di App Engine vuoto e pronto per le tue classi e risorse, con i file e le directory richiesti.
Endpoints Frameworks per App Engine	`hello-endpoints-archetype`	Genera un progetto di framework Endpoints di partenza per l'API backend App Engine, pronto per essere creato ed eseguito.

Creazione di 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 dei tuoi artefatti. Quando gli utenti utilizzano il tuo progetto nel proprio progetto Maven, questo funge da attributo della dipendenza che finiscono per specificare.
`artifactId`	Il nome del progetto in Maven. Viene specificato anche dai consumatori del tuo progetto quando dipendono da te nei loro progetti Maven.
`version`	La versione Maven iniziale con cui vuoi generare il progetto. È buona norma aggiungere a `version` il suffisso `-SNAPSHOT` perché questo fornisce supporto nel plug-in di release Maven per le versioni in fase di sviluppo. Per ulteriori informazioni, consulta la guida di Maven sull'utilizzo del plug-in di rilascio.
`package`	Il pacchetto Java creato durante la generazione.

Creazione di una nuova app Endpoints Frameworks

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

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

hello-endpoints-archetype genera un'API di esempio per i saluti utilizzando Endpoints Frameworks versione 2.0. Inoltre, funge da esempio per la migrazione delle applicazioni Endpoints Frameworks 1.0 alla versione 2.0.

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

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

Cambia directory in quella in cui vuoi compilare il progetto.
Esegui il seguente comando Maven:
```
mvn archetype:generate -Dgoogle-cloud-project=[YOUR-PROJECT-ID] -Dappengine-plugin=2.7.0 -Dendpoints-frameworks=2.1.0 -Dendpoints-plugin=1.0.2 -Dappengine-sdk=1.9.98 -Dfilter=com.google.appengine.archetypes:
```
Dove:
- -Dgoogle-cloud-project sia impostato sul tuo ID progetto.
- -Dappengine-plugin sia impostato sulla versione più recente del plug-in Maven di App Engine.
- -Dendpoints-frameworks sia impostato sulla versione più recente del framework Endpoints per App Engine per le dipendenze Maven.
- -Dendpoints-plugin sia impostato sulla versione più recente del plug-in Maven Endpoints Framework per App Engine.
Nota: Endpoints Frameworks per gli archetipi App Engine supporta Gradle e utilizza 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 necessari per i tuoi corsi, fornisci il numero corrispondente a endpoints-skeleton-archetype.
Seleziona la versione più recente dall'elenco visualizzato delle versioni degli archetipi disponibili.
Quando ti viene richiesto, Define value for property 'groupId' fornisci il nome del tuo spazio dei nomi per l'app; ad esempio, fornisci il valore com.example.helloendpoints.
Quando ti viene richiesto Define value for property 'artifactId', fornisci il nome del progetto. Ad esempio, fornisci 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 cambia directory con quella del nuovo progetto, ad esempio helloendpoints/.
Compila il progetto.
```
mvn clean package
```

Attendi il completamento della compilazione 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 eseguire test locali ed eseguire il deployment del progetto nell'ambiente standard di App Engine, consulta Gestione, test ed esecuzione del deployment di un progetto Maven.
Inoltre, puoi generare librerie client Java per l'API Greeting utilizzando il plug-in Maven 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 di API per un'API di saluti di esempio.
Constants.java contiene le costanti utilizzate dall'API di esempio Greetings.
HelloGreeting.java contiene un contenitore per i messaggi ricevuti e inviati dall'API di esempio Greetings.
index.html contiene un'interfaccia utente semplice per chiamare l'API di backend Greetings.
base.js contiene il codice JavaScript necessario per consentire all'interfaccia utente di effettuare richieste di backend.
build.gradle Una volta generato, l'esempio supporta anche Gradle e altre informazioni su questa funzionalità sono disponibili in README.md.

Compilazione e creazione dell'applicazione

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

Passa alla directory principale del progetto, ad esempio guestbook/.
Esegui Maven:
```
mvn clean package
```
Attendi il completamento della compilazione 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 la tua applicazione in qualsiasi momento sul 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 la tua app:
```
mvn clean package
```

Esegui l'esempio localmente:

mvn appengine:run

Attendi l'avvio del server. Quando il server è completamente avviato con la tua 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 andare all'indirizzo http://localhost:8080/ per accedere all'app.
Spegni l'applicazione e il server di sviluppo premendo Control+C.

Specifica di una porta per i test locali

Quando esegui l'applicazione nel server di sviluppo locale, la porta predefinita è 8080. Puoi modificare questo valore predefinito 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.7.0</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é sulla porta predefinita e viene specificato l'indirizzo 0.0.0.0, il che significa che il server di sviluppo è in ascolto per le richieste provenienti dalla rete locale.

Il prefisso devserver è facoltativo; puoi utilizzare <port>8181</port>.

Debug sul server di sviluppo

Per eseguire il debug di un'applicazione in esecuzione in locale, 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>

Deployment dell'applicazione

Per eseguire il deployment dell'applicazione:

mvn appengine:deploy

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

Passaggi successivi

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