Halaman ini diterjemahkan oleh Cloud Translation API.

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

Halaman ini menjelaskan cara mengelola project App Engine untuk Cloud Endpoints Frameworks API Anda menggunakan Apache Maven. Apache Maven adalah alat pengelolaan dan pemahaman project software yang dapat mem-build file Web Application Archive (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 SDK App Engine. 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, ikuti petunjuk 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 menetapkannya untuk menggunakan project ID Google Cloud yang berbeda dengan 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 untuk Java versi terbaru, jalankan gcloud components update.
Jika Anda tidak memiliki Java, download, instal, dan konfigurasikan.

Tetapkan flag 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, jalankan perintah berikut:
```
 mvn -v
```
Jika Anda belum menginstal versi Maven yang sesuai:
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 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.7.0</version>
</plugin>

Memilih arketipe App Engine

Archetype 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 Endpoints untuk App Engine	`endpoints-skeleton-archetype`	Membuat Framework Endpoint baru yang kosong untuk project API backend App Engine yang siap untuk class dan resource Anda sendiri, dengan file dan direktori yang diperlukan.
Framework Endpoints untuk App Engine	`hello-endpoints-archetype`	Membuat Framework Endpoints awal untuk project API backend App Engine, yang siap dibuat 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. Hal ini juga ditentukan oleh konsumen project Anda saat mereka bergantung pada Anda dalam project Maven mereka sendiri.
`version`	Versi Maven awal yang ingin Anda gunakan untuk membuat project. Sebaiknya `version` diakhiri dengan `-SNAPSHOT` karena hal ini memberikan dukungan di 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 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 menghasilkan contoh Greetings API 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 dihasilkan dengan arketipe memberikan informasi tentang tempat terjadinya migrasi.

Untuk membuat Framework Endpoints untuk project arketip API backend App Engine:

Ubah direktori ke direktori tempat Anda ingin mem-build 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 ditetapkan ke plugin Maven App Engine versi terbaru.
- -Dendpoints-frameworks ditetapkan ke versi terbaru Framework Endpoint untuk App Engine untuk dependensi Maven.
- -Dendpoints-plugin ditetapkan ke versi terbaru plugin Maven Endpoints Framework untuk App Engine.
Catatan: Endpoints Framework 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 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/.
Build project.
```
mvn clean package
```

Tunggu hingga project selesai di-build. Saat project berhasil selesai, pesan yang mirip dengan berikut ini 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 menggunakan Plugin Maven Framework 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 dalam 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 agar UI dapat membuat permintaan backend.
Setelah dihasilkan, build.gradle juga mendukung Gradle dan informasi selengkapnya tentang fungsi ini di README.md.

Mengompilasi dan mem-build aplikasi

Untuk mem-build aplikasi yang dibuat dengan arketipe App Engine Maven:

Ubah ke direktori utama untuk project Anda, misalnya, guestbook/.
Jalankan Maven:
```
mvn clean package
```
Tunggu hingga project selesai di-build. Saat project berhasil selesai, pesan yang mirip dengan berikut ini 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 aplikasi Framework Endpoint untuk App Engine:

Jika Anda belum melakukannya, build 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 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 default-nya 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:

<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 ditentukan, yang berarti server pengembangan memproses permintaan yang masuk dari jaringan lokal.

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

Proses debug pada server pengembangan

Untuk men-debug aplikasi yang berjalan secara lokal, tetapkan jvmFlags dalam 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 selanjutnya

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 Framework Endpoints dan laporkan masalah di GitHub.
Pelajari cara menentukan parameter untuk sasaran dengan melihat plugin Maven Framework Cloud Endpoints.