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 mem-build file Web Application Archive (WAR) untuk deployment 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 perintah untuk memilih region tempat Anda ingin aplikasi App Engine berada.
Download dan instal gcloud CLI, lalu lakukan inisialisasi Google Cloud CLI.
Jika Anda sudah menginstal Google Cloud CLI dan ingin menyetelnya untuk menggunakan ID project Google Cloud lain daripada yang Anda 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 belum memiliki Java, download, instal, dan konfigurasikan.

Tetapkan flag compiler Java di pom.xml project Anda untuk menentukan bytecode 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 belum 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 Maven App Engine ke project yang sudah ada (opsional)

Untuk menggunakan plugin Maven App Engine dalam project Maven yang 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.8.1</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
Endpoints Frameworks untuk App Engine	`endpoints-skeleton-archetype`	Membuat project API backend Endpoints Frameworks for App Engine baru yang kosong dan siap untuk class dan resource Anda sendiri, dengan file dan direktori yang diperlukan.
Endpoints Frameworks untuk App Engine	`hello-endpoints-archetype`	Membuat project API backend Endpoints Frameworks untuk App Engine starter, yang siap dibangun dan dijalankan.

Membuat project baru menggunakan Maven

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

Istilah	Arti
`groupId`	Namespace dalam Maven untuk melacak artefak Anda. Saat 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. Library ini juga ditentukan oleh konsumen project Anda saat mereka bergantung pada Anda di project Maven mereka sendiri.
`version`	Versi Maven awal yang Anda inginkan untuk project Anda. Sebaiknya `version` diberi akhiran `-SNAPSHOT` karena hal ini memberikan dukungan di plugin rilis Maven untuk versi yang sedang dalam pengembangan. Untuk mengetahui informasi selengkapnya, lihat panduan Maven tentang cara menggunakan plugin rilis.
`package`	Paket Java yang dibuat selama pembuatan.

Membuat aplikasi Endpoints Frameworks baru

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

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

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

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

Untuk membuat project pola dasar API backend Endpoints Frameworks for App Engine:

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

Catatan: Untuk membuat project kosong yang berisi struktur direktori dan file yang diperlukan serta siap untuk class Anda sendiri, berikan angka 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/.
Bangun project.
```
mvn clean package
```

Tunggu hingga project selesai dibangun. 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, tinjau Mengelola, menguji, dan men-deploy project Maven.
Selain itu, Anda dapat membuat library klien Java untuk Greeting API dengan menggunakan Plugin Maven Frameworks Endpoints:
```
mvn endpoints-framework:clientLibs
```

Diagram berikut menunjukkan tata letak project dasar 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 Greetings API contoh.
index.html berisi UI sederhana untuk memanggil Greetings API backend.
base.js berisi JavaScript yang diperlukan agar UI dapat membuat permintaan backend.
build.gradle setelah dibuat, contoh ini juga mendukung Gradle dan informasi selengkapnya tentang fungsi ini di README.md.

Mengompilasi dan membangun aplikasi Anda

Untuk membuat aplikasi yang dibuat dengan arketipe Maven App Engine:

Ubah ke direktori utama project Anda, misalnya, guestbook/.
Jalankan Maven:
```
mvn clean package
```
Tunggu hingga project selesai dibangun. 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 Maven App Engine.

Untuk menguji aplikasi Endpoints Frameworks for App Engine:

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

Jalankan contoh secara lokal:

mvn appengine:run

Tunggu hingga server dimulai. Saat server sepenuhnya dimulai dengan aplikasi Anda berjalan, pesan yang mirip dengan berikut 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 Anda 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 default ini dengan mengubah entri plugin untuk appengine-maven-plugin. Misalnya, Anda dapat menentukan port dan alamat dalam file pom.xml direktori aplikasi Anda:

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

Dalam contoh ini, <devserver.port> menetapkan port ke 8181, bukan default, dan alamat 0.0.0.0 ditentukan, yang berarti server pengembangan memantau 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 di konfigurasi plugin untuk mengaktifkan proses debug di 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 Maven App Engine memiliki parameter terkait yang dapat Anda gunakan. Untuk mengetahui daftar lengkap sasaran dan parameter, lihat Sasaran dan parameter plugin Maven App Engine.

Langkah berikutnya

Pelajari kode plugin Maven App Engine 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.