Membuat kontainer aplikasi Java

  • 10 menit

Di unit ini, Anda membuat kontainer aplikasi Java.

Seperti disebutkan sebelumnya, kontainer berjalan langsung di atas sistem operasi host, kernel, dan perangkat keras sebagai proses sistem biasa. Kontainer memerlukan lebih sedikit sumber daya sistem, menghasilkan jejak yang lebih kecil, lebih sedikit overhead, dan waktu mulai aplikasi yang lebih cepat. Manfaat ini adalah kasus penggunaan yang bagus untuk penskalaan sesuai permintaan.

Ada kontainer Windows dan kontainer Linux. Dalam modul ini, Anda menggunakan runtime Docker yang banyak digunakan untuk membangun gambar kontainer Linux. Anda kemudian menyebarkan gambar kontainer Linux ke sistem operasi host komputer lokal Anda. Terakhir, Anda menyebarkan gambar kontainer Linux ke Azure Kubernetes Service.

Gambaran umum Docker

Docker runtime digunakan untuk membuat, mengambil, menjalankan, dan mengunggah citra kontainer, seperti yang ditunjukkan dalam diagram berikut.

Diagram memperlihatkan perintah Docker.

Tabel berikut ini menjelaskan setiap perintah Docker:

Perintah Docker Deskripsi
docker build Membangun gambar kontainer yang terdiri dari instruksi atau lapisan yang diperlukan Docker untuk membuat kontainer yang sedang berjalan dari gambar. Hasil dari perintah ini adalah gambar.
docker pull Kontainer diinisialisasi dari gambar, yang ditarik dari registri seperti Azure Container Registry. Registri ini adalah tempat Azure Kubernetes Service mengambil. Hasil dari perintah ini adalah pengambilan gambar melalui jaringan di Azure. Secara opsional, Anda dapat menarik gambar secara lokal. Opsi ini umum saat membuat gambar yang memerlukan dependensi atau lapisan yang mungkin dibutuhkan aplikasi Anda, seperti server aplikasi.
docker run Instans gambar yang sedang berjalan adalah kontainer, dan perintah ini menjalankan semua lapisan yang diperlukan untuk menjalankan dan berinteraksi dengan aplikasi kontainer yang sedang berjalan. Hasil dari perintah ini adalah proses aplikasi yang berjalan pada sistem operasi host.
docker push Azure Container Registry menyimpan citra sehingga tersedia dan berada dekat dengan jaringan untuk penerapan dan penskalaan Azure.

Mengkloning aplikasi Java

Pertama, kloning repositori Flight Booking System for Airline Reservations dan navigasikan ke folder proyek aplikasi web Airlines.

Nota

Jika pembuatan Azure Kubernetes Service selesai di tab CLI Anda, gunakan tab tersebut. Jika masih berjalan, buka tab baru dan navigasikan ke lokasi tempat Anda lebih suka mengkloning Sistem Pemesanan Penerbangan untuk Reservasi Maskapai.

Jalankan perintah berikut:

git clone https://github.com/Azure-Samples/containerize-and-deploy-Java-app-to-Azure.git
cd containerize-and-deploy-Java-app-to-Azure/Project/Airlines

Secara opsional, jika Anda telah menginstal Java dan Maven, Anda dapat menjalankan perintah berikut di konsol terminal Anda untuk merasakan pengalaman membangun aplikasi tanpa Docker. Jika Anda tidak menginstal Java dan Maven, Anda dapat dengan aman melanjutkan ke bagian berikutnya, Membuat file Docker. Di bagian itu, Anda menggunakan Docker untuk menarik Java dan Maven untuk menjalankan build atas nama Anda.

mvn clean package

Nota

Kami menggunakan perintah mvn clean package untuk mengilustrasikan tantangan operasional dari tidak menggunakan Docker build multistage, yang akan kami bahas berikutnya. Sekali lagi, langkah ini bersifat opsional. Bagaimanapun, Anda dapat dengan aman melanjutkan tanpa menjalankan perintah Maven.

Jika proses berhasil, Maven berhasil membangun artefak Sistem Pemesanan Penerbangan untuk Aplikasi Web Reservasi Maskapai Penerbangan Arsip AirlinesReservationSample-0.0.1-SNAPSHOT.war, seperti yang ditunjukkan dalam output berikut:

[INFO] Building war: $PROJECT_PATH/containerize-and-deploy-Java-app-to-Azure/Project/Airlines/target/AirlinesReservationSample-0.0.1-SNAPSHOT.war
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  11.776 s
[INFO] Finished at: 2024-11-15T09:33:26+09:00
[INFO] ------------------------------------------------------------------------

Bayangkan Anda adalah pengembang Java dan Anda baru saja membuat AirlinesReservationSample-0.0.1-SNAPSHOT.war. Langkah Anda selanjutnya mungkin bekerja dengan teknisi operasi untuk menyebarkan artefak ini ke server lokal atau komputer virtual. Agar aplikasi berhasil memulai dan berjalan, server dan komputer virtual harus tersedia dan dikonfigurasi dengan dependensi yang diperlukan. Proses ini menantang dan memakan waktu, terutama sesuai permintaan ketika peningkatan beban mencapai aplikasi Anda. Dengan kontainer, tantangan ini dikurangi.

Membuat Dockerfile

Anda sekarang siap untuk membangun Dockerfile. Dockerfile adalah dokumen teks yang berisi semua perintah yang akan dijalankan pengguna pada baris perintah untuk merakit gambar kontainer. Setiap gambar adalah lapisan yang dapat di-cache untuk efisiensi. Lapisan-lapisan dibangun di atas satu sama lain.

Misalnya, Sistem Pemesanan Penerbangan untuk Reservasi Maskapai perlu disebarkan dan dijalankan di dalam server aplikasi. Server aplikasi tidak termasuk dalam AirlinesReservationSample-0.0.1-SNAPSHOT.war. Ini adalah dependensi eksternal yang diperlukan agar AirlinesReservationSample-0.0.1-SNAPSHOT.war berjalan, mendengarkan, dan memproses permintaan HTTP, mengelola sesi pengguna, dan memfasilitasi pemesanan penerbangan. Jika Anda menggunakan penyebaran tradisional dan non-kontainer, teknisi operasi akan menginstal dan mengonfigurasi server aplikasi di beberapa server fisik atau komputer virtual sebelum menyebarkan AirlinesReservationSample-0.0.1-SNAPSHOT.war ke dalamnya. Teknisi operasi ini juga perlu memastikan bahwa JDK yang digunakan pada komputer Anda - yang merupakan apa yang mvn clean package digunakan untuk mengkompilasi file WAR - sebenarnya sesuai dengan JRE yang sama yang digunakan oleh server aplikasi. Mengelola dependensi ini menantang dan memakan waktu.

Dengan Dockerfile, Anda dapat menulis instruksi atau lapisan yang diperlukan untuk secara otomatis mencapai tujuan ini, dengan menambahkan langkah-langkah yang diperlukan untuk memastikan bahwa Sistem Pemesanan Tiket Penerbangan untuk Reservasi Maskapai memiliki semua dependensi yang diperlukan untuk disebarkan ke lingkungan Docker container. Solusi ini menarik ketika Anda bekerja dengan skala sesuai permintaan pada interval yang tidak terencana. Setiap lapisan menggunakan cache Docker, yang berisi status gambar kontainer pada setiap tonggak instruksional, mengoptimalkan waktu komputasi dan menggunakan kembali. Jika lapisan tidak berubah, lapisan yang di-cache akan digunakan. Kasus penggunaan umum untuk lapisan cache adalah runtime Java, server aplikasi, dan dependensi lain untuk aplikasi Web Flight Booking System for Airline Reservations. Jika dan ketika versi berubah pada lapisan yang di-cache sebelumnya, entri cache baru dibuat.

Diagram berikut menggambarkan lapisan gambar kontainer. Ketika perintah di Dockerfile dijalankan, lapisan dibuat. Lapisan atas adalah sistem pemesanan penerbangan baca/tulis untuk lapisan aplikasi web Reservasi Maskapai. Lapisan tersebut dibangun di atas lapisan sebelumnya yang bersifat baca-saja.

Diagram memperlihatkan lapisan Docker.

Docker memiliki konsep build multitahap, fitur yang memungkinkan Anda membuat gambar kontainer yang lebih kecil dengan cache yang lebih baik dan dampak keamanan yang lebih kecil, memungkinkan peningkatan pengoptimalan dan pemeliharaan Dockerfile dari waktu ke waktu. Misalnya, Anda dapat memisahkan tahap build kontainer untuk mengkompilasi dan membangun aplikasi dari tahap untuk menjalankan aplikasi. Fitur ini memungkinkan Anda untuk hanya menyalin artefak yang dihasilkan selama proses pembangunan ke dalam gambar kontainer produksi, yang dapat mengurangi ukuran atau penggunaan sumber daya. Karena gambar kontainer di-cache, jika tidak ada perubahan, gambar yang di-cache dapat digunakan kembali, mengurangi biaya dan waktu pengunduhan dari jaringan.

Layanan yang diekspos di lingkungan produksi harus dikelola dengan hati-hati untuk keamanan. Oleh karena itu, lingkungan produksi menggunakan dan mengoperasikan gambar kontainer yang aman. Contohnya menggunakan gambar yang CBL-Mariner disediakan oleh Microsoft.

CBL-Mariner Linux adalah sistem operasi ringan, hanya berisi paket yang diperlukan untuk lingkungan cloud. Anda dapat menyesuaikannya melalui paket dan alat kustom agar sesuai dengan persyaratan aplikasi Anda. CBL-Mariner menjalani pengujian validasi Azure dan kompatibel dengan agen Azure. Microsoft membangun dan menguji CBL-Mariner untuk mendukung berbagai kasus penggunaan, mulai dari layanan Azure hingga mendukung infrastruktur IoT. Ini adalah distribusi Linux yang direkomendasikan secara internal untuk digunakan dengan layanan cloud Microsoft dan produk terkait.

Nota

Microsoft menyediakan kontainer gambar yang dibundel dengan OpenJDK, termasuk gambar Ubuntu, CBL-Mariner, dan distroless. Gambar distroless memiliki ukuran gambar terkecil, tetapi menjalankan Tomcat di atasnya sangat menantang. Untuk mencapai desain yang ringan, distroless gambar menghapus banyak perintah dan alat, termasuk shell, yang berarti Anda tidak dapat memanggil catalina.sh untuk memulai Tomcat. Gambar distroless ini cocok untuk menjalankan JAR yang dapat dieksekusi, seperti yang digunakan dengan Spring Boot atau Quarkus.

Dalam contoh berikut, versi Microsoft Build of OpenJDK yang sama digunakan dalam tahap build dan tahap akhir. Pendekatan ini memastikan bahwa Anda mengompilasi kode sumber dengan versi JDK yang sama dengan yang digunakan dalam penyebaran layanan Tomcat, yang membantu menghindari masalah tak terduga akibat ketidakcocokan versi.

Gambar berikut menggambarkan build multitahap dan apa yang terjadi di setiap tahap berdasarkan perintah yang ditentukan dalam Dockerfile:

Diagram yang menunjukkan build multistage Docker.

Pada tahap 0, Tomcat diunduh dan diekstraksi ke dalam direktori yang ditentukan oleh variabel lingkungan pada gambar Ubuntu. Variabel TOMCAT_VERSION menentukan versi Tomcat yang akan diunduh. Jika versi baru Tomcat dirilis, Anda harus memperbarui nomor versi, karena gambar baru hanya diambil saat nomor versi berubah. Jika tidak, gambar yang di-cache digunakan. Tomcat yang diunduh disalin ke lingkungan tahap akhir untuk digunakan.

Pada tahap 1, Maven diinstal pada gambar Ubuntu, dan kode sumber dan file konfigurasi yang dibuat disalin sebelum membangun proyek Maven. Setiap lapisan di-cache, sehingga gambar OS dan lapisan gambar Maven menggunakan kembali cache. Jika file konfigurasi, file kode sumber, atau direktori web diperbarui, lapisan dari perubahan dan seterusnya dibangun kembali. Jika build berhasil diselesaikan tanpa kesalahan selama kompilasi, artefak bernama AirlinesReservationSample-0.0.1-SNAPSHOT.war dihasilkan di bawah direktori target . Artefak ini disalin ke lingkungan tahap akhir untuk digunakan.

Pada tahap akhir, gambar aman CBL-Mariner yang disediakan oleh Microsoft digunakan untuk menyalin artefak build Tomcat dari tahap 0 dan artefak build Java dari tahap 1. Pengguna bernama app memiliki semua file yang digunakan dalam proyek, dan aplikasi juga dijalankan sebagai app pengguna alih-alih memiliki root hak istimewa. Penyiapan ini memastikan bahwa gambar kontainer dapat dioperasikan dengan aman tanpa memberikan izin yang tidak perlu. Akhirnya, nomor port 8080 diekspos, dan skrip catalina.sh dijalankan untuk memulai Tomcat. Ketika ini dijalankan di Docker Desktop lokal Anda, Anda dapat mengaksesnya melalui URL http://localhost:8080/AirlinesReservationSample.

Dalam folder akar proyek Anda, containerize-and-deploy-Java-app-to-Azure/Project/Airlines, gunakan perintah berikut untuk membuat file yang disebut Dockerfile:

vi Dockerfile

Tambahkan konten berikut ke Dockerfile Anda, lalu simpan dan keluar. Untuk menyimpan dan keluar, tekan ESC, ketik :wq!, lalu tekan Enter.

############################################
# Tomcat Intall stage
############################################
FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS tomcat

ENV CATALINA_HOME=/usr/local/tomcat

# Configure Tomcat Version (Be sure to use the latest version)
ENV TOMCAT_VERSION=10.1.33

# Install Tomcat and required packages
RUN apt-get update ; \
    apt-get install -y curl ; \
    curl -O https://downloads.apache.org/tomcat/tomcat-10/v${TOMCAT_VERSION}/bin/apache-tomcat-${TOMCAT_VERSION}.tar.gz ; \
    tar xzf apache-tomcat-${TOMCAT_VERSION}.tar.gz ; \
    mv apache-tomcat-${TOMCAT_VERSION} ${CATALINA_HOME} ; \
    rm apache-tomcat-${TOMCAT_VERSION}.tar.gz && \
    apt-get remove --purge -y curl && \
    apt-get autoremove -y && \
    apt-get clean

############################################
# Build stage (Compiles with Java 17)
############################################
FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS build

WORKDIR /build

# Install Maven
RUN apt-get update && apt-get install -y maven && mvn --version

# Copy source code
COPY pom.xml .
COPY src ./src
COPY web ./web

# Build the project
RUN mvn clean package

############################################
# Package final stage
############################################
FROM mcr.microsoft.com/openjdk/jdk:17-mariner

# Configure the location of the Tomcat installation
ENV CATALINA_HOME=/usr/local/tomcat
# Configure the path to the Tomcat binaries
ENV PATH=$CATALINA_HOME/bin:$PATH

# This is the user that runs the Tomcat process
USER app

# Copy the Tomcat installation from the Tomcat stage
COPY --chown=app:app --from=tomcat ${CATALINA_HOME} ${CATALINA_HOME}
# Copy the Tomcat configuration files
COPY --chown=app:app tomcat-users.xml ${CATALINA_HOME}/conf
# Copy the compiled WAR file from the build stage
COPY --chown=app:app --from=build /build/target/*.war ${CATALINA_HOME}/webapps/AirlinesReservationSample.war

# Expose the default Tomcat port
EXPOSE 8080
# Start Tomcat
CMD ["catalina.sh", "run"]

Nota

Secara opsional, Anda dapat menggunakan file Dockerfile_Solution di akar proyek Anda, yang berisi konten yang Anda butuhkan.

Dockerfile dibagi menjadi tiga tahap, yang dijelaskan dalam tabel berikut:

  • Tahap penginstalan Tomcat:

    Perintah Docker Deskripsi
    FROM FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS tomcat mengatur gambar dasar ke Microsoft Build OpenJDK 17 di Ubuntu, dan menamai tahap ini tomcat. Di sinilah Tomcat diinstal.
    ENV ENV CATALINA_HOME=/usr/local/tomcat mengatur variabel lingkungan untuk direktori penginstalan Tomcat.
    ENV ENV TOMCAT_VERSION=10.1.33 mengatur versi Tomcat yang akan diinstal. Ini harus diperbarui ke versi terbaru sesuai kebutuhan.
    RUN RUN Perintah memperbarui daftar paket, menginstal curl, mengunduh versi Tomcat yang ditentukan, mengekstraknya, memindahkannya ke direktori yang ditentukan, dan membersihkan file dan paket yang tidak perlu. Ini memastikan bahwa gambar tetap ringan.

  • Tahap Build, yang menggunakan Java 17 untuk kompilasi:

    Perintah Docker Deskripsi
    FROM FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS build mengatur gambar dasar ke Microsoft Build OpenJDK 17 di Ubuntu, dan menamai tahap ini build. Tahap ini digunakan untuk mengkompilasi aplikasi Java.
    WORKDIR WORKDIR /build mengatur direktori kerja di dalam kontainer ke /build, tempat kode sumber disalin dan dikompilasi.
    RUN RUN apt-get update && apt-get install -y maven && mvn --version menginstal Maven, alat otomatisasi build yang digunakan untuk proyek Java, dan memverifikasi penginstalannya.
    COPY COPY pom.xml . menyalin file konfigurasi Maven ke direktori kerja. File ini sangat penting untuk membangun proyek.
    COPY COPY src ./src menyalin direktori kode sumber ke dalam kontainer. Di sinilah kode aplikasi Java berada.
    COPY COPY web ./web menyalin direktori sumber daya web ke dalam kontainer. Ini termasuk sumber daya aplikasi web yang diperlukan untuk pembangunan.
    RUN RUN mvn clean package menjalankan proses build Maven, yang mengkompilasi aplikasi Java dan mengemasnya ke dalam file WAR.

  • Tahap akhir Paket:

    Perintah Docker Deskripsi
    FROM FROM mcr.microsoft.com/openjdk/jdk:17-mariner mengatur citra dasar ke Microsoft Build OpenJDK 17 pada CBL-Mariner, yang digunakan untuk penyebaran akhir aplikasi.
    ENV ENV CATALINA_HOME=/usr/local/tomcat mengatur variabel lingkungan untuk direktori penginstalan Tomcat, mirip dengan tahap penginstalan.
    ENV ENV PATH=$CATALINA_HOME/bin:$PATH menambahkan direktori bin Tomcat ke sistem PATH, yang memungkinkan perintah Tomcat dijalankan dengan mudah.
    USER USER app menentukan pengguna di bawah tempat proses Tomcat berjalan, meningkatkan keamanan dengan tidak berjalan sebagai pengguna root.
    COPY COPY --chown=app:app --from=tomcat ${CATALINA_HOME} ${CATALINA_HOME} menyalin penginstalan Tomcat dari tomcat staging, menetapkan kepemilikan kepada pengguna app.
    COPY COPY --chown=app:app tomcat-users.xml ${CATALINA_HOME}/conf menyalin file konfigurasi pengguna Tomcat ke dalam kontainer, menjadikan app sebagai pemilik.
    COPY COPY --chown=app:app --from=build /build/target/*.war ${CATALINA_HOME}/webapps/AirlinesReservationSample.war menyalin file WAR yang dikompilasi dari build tahap ke direktori aplikasi web Tomcat, mengatur kepemilikan kepada app pengguna.
    EXPOSE EXPOSE 8080 mengekspos port 8080, port default untuk Tomcat, memungkinkan akses eksternal ke aplikasi.
    CMD CMD ["catalina.sh", "run"] menentukan perintah untuk memulai Tomcat saat kontainer dijalankan.

Untuk informasi selengkapnya tentang konstruksi Dockerfile, lihat referensi Dockerfile.