Menggunakan Apache Maven dan plugin App Engine (berbasis Google Cloud CLI)

Halaman ini menjelaskan cara mengelola project App Engine untuk Cloud Endpoints Frameworks API menggunakan Apache Maven. Apache Maven adalah alat pengelolaan dan pemahaman project software yang mampu membuat file Arsip Aplikasi Web (WAR) untuk di-deploy ke App Engine. Google menyediakan plugin dan Arketipe Maven yang didukung oleh Maven 3.3.9 atau yang lebih baru.

Maven mendownload library Java dari App Engine SDK. Anda dapat menggunakan Maven untuk menguji aplikasi secara lokal dan men-deploy-nya ke App Engine.

Sebelum memulai

Gunakan konsol Google Cloud untuk membuat dan menyiapkan project Google Cloud Anda:

Buka App Engine
1. Pilih atau buat project Google Cloud baru.
2. Jika Anda perlu membuat aplikasi App Engine untuk project Anda, ikuti petunjuk untuk memilih region tempat Anda ingin aplikasi App Engine berada.
Download dan instal gcloud CLI, lalu inisialisasi Google Cloud CLI.
Jika Anda sudah menginstal Google Cloud CLI dan ingin menetapkannya agar menggunakan ID project Google Cloud yang berbeda dengan yang Anda gunakan untuk melakukan inisialisasi, lihat Mengelola konfigurasi gcloud CLI.
Instal komponen app-engine-java gcloud CLI:
```
gcloud components install app-engine-java
```
Catatan: Untuk memastikan Anda memiliki gcloud CLI versi terbaru untuk Java, jalankan gcloud components update.
Jika Anda tidak memiliki Java, download, instal, dan konfigurasikan.

Tetapkan tanda compiler Java di pom.xml project Anda untuk menentukan kode byte Java 8:

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

Anda harus menginstal Apache Maven versi 3.3.9 atau yang lebih baru. Untuk menentukan versi Maven Anda, jalankan perintah berikut:
```
 mvn -v
```
Jika Anda tidak menginstal Maven versi yang tepat:
1. Download Maven versi 3.3.9 atau yang lebih baru dari situs Maven.
2. Instal Maven di komputer lokal Anda.
  Catatan: Pengguna Linux mungkin perlu mendownload Maven, bukan menggunakan apt-get install.

Menambahkan plugin App Engine Maven ke project yang ada (opsional)

Untuk menggunakan plugin Maven App Engine dalam project Maven yang sudah ada, tambahkan kode berikut ke bagian plugins dalam file pom.xml project:

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

Memilih arketipe App Engine

Arketipe Maven memungkinkan pengguna membuat project Maven menggunakan template yang mencakup skenario umum. App Engine memanfaatkan fitur Maven ini untuk menyediakan beberapa arketipe App Engine yang berguna di Maven Central. Pilih arketipe App Engine yang sesuai untuk aplikasi Anda:

Jenis aplikasi	Artefak	Deskripsi
Framework Endpoint untuk App Engine	`endpoints-skeleton-archetype`	Membuat Framework Endpoint baru yang kosong untuk project API backend App Engine yang siap digunakan untuk class dan resource Anda sendiri, dengan file dan direktori yang diperlukan.
Framework Endpoint untuk App Engine	`hello-endpoints-archetype`	Menghasilkan Framework Endpoints awal untuk project API backend App Engine, yang siap untuk di-build dan dijalankan.

Membuat project baru menggunakan Maven

Selama pembuatan project, Maven akan meminta Anda untuk menyediakan groupId, artifactId, version, dan package untuk project tersebut.

Masa Berlaku	Arti
`groupId`	Namespace dalam Maven untuk melacak artefak Anda. Ketika orang menggunakan project Anda di Project Maven mereka sendiri, project tersebut berfungsi sebagai atribut dependensi yang akhirnya mereka tentukan.
`artifactId`	Nama project Anda dalam Maven. Nama ini juga ditentukan oleh konsumen project Anda jika mereka bergantung pada Anda dalam project Maven mereka sendiri.
`version`	Versi Maven awal yang ingin Anda gunakan untuk membuat project. Sebaiknya tambahkan akhiran `version` dengan `-SNAPSHOT` karena hal ini memberikan dukungan dalam plugin rilis Maven untuk versi yang sedang dalam pengembangan. Untuk informasi selengkapnya, lihat Panduan Maven untuk menggunakan plugin rilis.
`package`	Paket Java yang dibuat selama pembuatan.

Membuat aplikasi Framework Endpoint baru

Bagian ini menjelaskan cara membuat project Endpoints Frameworks versi 2.0 baru.

hello-endpoints-archetype memberikan contoh penggunaan plugin, termasuk plugin App Engine Maven dan plugin Maven Endpoint Frameworks.

hello-endpoints-archetype membuat contoh Greetings API menggunakan Endpoints Frameworks versi 2.0. Framework ini juga berfungsi sebagai contoh untuk memigrasikan aplikasi Endpoints Frameworks versi 1.0 ke Framework Endpoint versi 2.0.

README.md yang dibuat dengan arketipe memberikan informasi tentang tempat migrasi terjadi.

Untuk membuat Framework Endpoints bagi project arsitektur API backend App Engine:

Ubah direktori ke direktori tempat Anda ingin membuat project.
Jalankan perintah Maven berikut:
```
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:
```
Dengan keterangan:
- -Dgoogle-cloud-project ditetapkan ke project ID Anda.
- -Dappengine-plugin disetel ke versi terbaru plugin Maven App Engine.
- -Dendpoints-frameworks disetel ke versi terbaru Framework Endpoint untuk App Engine bagi dependensi Maven.
- -Dendpoints-plugin disetel ke versi terbaru Framework Endpoint untuk plugin App Engine Maven.
Catatan: Framework Endpoint untuk arketipe App Engine memiliki dukungan Gradle dan menggunakan versi terbaru dari setiap dependensi.
Berikan angka yang sesuai dengan hello-endpoints-archetype.

Catatan: Untuk membuat project kosong yang berisi struktur direktori dan file yang diperlukan yang siap untuk class Anda sendiri, berikan nomor yang sesuai dengan endpoints-skeleton-archetype.
Pilih versi terbaru dari daftar versi arketipe yang tersedia yang ditampilkan.
Saat diminta ke Define value for property 'groupId', berikan namespace untuk aplikasi Anda; misalnya, berikan nilai com.example.helloendpoints.
Saat diminta ke Define value for property 'artifactId', berikan nama project; misalnya, berikan nilai helloendpoints.
Saat diminta ke Define value for property 'version', terima nilai default.
Saat diminta ke Define value for property 'package', terima nilai default.
Saat diminta untuk mengonfirmasi pilihan Anda, setujui nilai default dengan memasukkan Y.
Tunggu hingga project selesai dibuat. lalu ubah direktori ke direktori project baru, misalnya helloendpoints/.
Buat project.
```
mvn clean package
```

Tunggu hingga project selesai dibuat. Jika project berhasil diselesaikan, pesan yang mirip dengan berikut akan ditampilkan:

[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] ------------------------------------------------------------------------

Untuk menguji secara lokal dan men-deploy project ke lingkungan standar App Engine, pelajari Mengelola, menguji, dan men-deploy project Maven.
Selain itu, Anda dapat membuat library klien Java untuk Greeting API menggunakan Plugin Maven Framework Endpoint:
```
mvn endpoints-framework:clientLibs
```

Diagram berikut menunjukkan tata letak project dasar untuk Greetings API:

Tata Letak Project Maven

README.md berisi informasi tentang contoh yang dihasilkan.
Greetings.java berisi definisi API untuk contoh Greetings API.
Constants.java berisi konstanta yang digunakan oleh contoh Greetings API.
HelloGreeting.java berisi penampung untuk pesan yang diterima dan dikirim dari contoh Greetings API.
index.html berisi UI sederhana untuk memanggil Greetings API backend.
base.js berisi JavaScript yang diperlukan untuk UI guna membuat permintaan backend.
build.gradle setelah dibuat, contoh juga mendukung Gradle dan informasi selengkapnya tentang fungsi ini di README.md.

Mengompilasi dan membangun aplikasi

Untuk membangun aplikasi yang dibuat dengan arketipe Maven App Engine:

Ubah ke direktori utama untuk project Anda, misalnya, guestbook/.
Jalankan Maven:
```
mvn clean package
```
Tunggu hingga project selesai dibuat. Jika project berhasil diselesaikan, pesan yang mirip dengan berikut akan ditampilkan:
```
BUILD SUCCESS
 Total time: 10.724s
 Finished at: 2016-08-04T16:18:24-07:00
 Final Memory: 24M/213M
```

Menguji aplikasi dengan server pengembangan

Selama fase pengembangan, Anda dapat menjalankan dan menguji aplikasi kapan saja di server pengembangan dengan menjalankan plugin App Engine Maven.

Untuk menguji Framework Endpoints untuk aplikasi App Engine:

Jika Anda belum melakukannya, build aplikasi Anda:
```
mvn clean package
```

Jalankan contoh secara lokal:

mvn appengine:run

Tunggu hingga server dimulai. Setelah server benar-benar dimulai saat aplikasi Anda berjalan, pesan yang mirip dengan berikut ini akan ditampilkan:

[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

Gunakan browser untuk membuka http://localhost:8080/ guna mengakses aplikasi Anda.
Matikan aplikasi dan server pengembangan dengan menekan Control+C.

Menentukan port untuk pengujian lokal

Saat Anda menjalankan aplikasi di server pengembangan lokal, port defaultnya adalah 8080. Anda dapat mengubah setelan default ini dengan mengubah entri plugin untuk appengine-maven-plugin. Misalnya, Anda dapat menentukan port dan alamat dalam file pom.xml direktori aplikasi:

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

Dalam contoh ini, <devserver.port> menetapkan port ke 8181, bukan default, dan alamat 0.0.0.0 ditetapkan, yang berarti server pengembangan memproses permintaan yang masuk dari jaringan lokal.

Awalan devserver bersifat opsional; Anda dapat menggunakan <port>8181</port> sebagai gantinya.

Proses debug pada server pengembangan

Untuk men-debug aplikasi yang berjalan secara lokal, tetapkan jvmFlags dalam konfigurasi plugin untuk mengaktifkan proses debug pada JVM yang mendasarinya, misalnya:

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

Men-deploy aplikasi Anda

Untuk men-deploy aplikasi Anda:

mvn appengine:deploy

Sasaran appengine:deploy dan semua sasaran lainnya di plugin App Engine Maven memiliki parameter terkait yang dapat Anda gunakan. Untuk mengetahui daftar lengkap sasaran dan parameter, lihat Sasaran dan parameter plugin App Engine Maven.

Langkah selanjutnya

Pelajari kode plugin App Engine Maven dan laporkan masalah di GitHub.
Pelajari cara menentukan parameter untuk sasaran dengan melihat Sasaran dan Parameter Maven App Engine.
Pelajari kode plugin Maven Endpoints Frameworks dan laporkan masalah di GitHub.
Pelajari cara menentukan parameter untuk sasaran dengan melihat plugin Maven Cloud Endpoints Frameworks.