การทําให้แอป Java เป็นคอนเทนเนอร์

10 นาที

ในหน่วยนี้ คุณจัดเก็บแอปพลิเคชัน Java

ตามที่กล่าวถึงก่อนหน้านี้ คอนเทนเนอร์จะทํางานบนด้านบนของระบบปฏิบัติการโฮสต์ เคอร์เนล และฮาร์ดแวร์เป็นกระบวนการระบบทั่วไปโดยตรง คอนเทนเนอร์ต้องการทรัพยากรระบบน้อยลง ส่งผลให้มีฟุตพริ้นท์ขนาดเล็กลง ค่าใช้จ่ายน้อยลง และเวลาเริ่มต้นแอปพลิเคชันที่เร็วขึ้น ประโยชน์เหล่านี้เป็นกรณีใช้งานที่ยอดเยี่ยมสําหรับการปรับขนาดตามความต้องการ

มีคอนเทนเนอร์ Windows และ Linux ในโมดูลนี้ คุณใช้รันไทม์ Docker ที่ใช้กันทั่วไปเพื่อสร้างรูปภาพคอนเทนเนอร์ของ Linux จากนั้นคุณปรับใช้อิมเมจคอนเทนเนอร์ Linux ไปยังระบบปฏิบัติการโฮสต์ของเครื่องภายในของคุณ สุดท้าย คุณปรับใช้รูปภาพคอนเทนเนอร์ Linux กับบริการ Azure Kubernetes

ภาพรวม Docker

รันไทม์ Docker ใช้เพื่อสร้าง ดึง เรียกใช้ และพุชรูปภาพคอนเทนเนอร์ ดังที่แสดงในไดอะแกรมต่อไปนี้:

ตารางต่อไปนี้อธิบายคําสั่ง Docker แต่ละคําสั่ง:

คําสั่ง Docker	คำอธิบาย
`docker build`	สร้างรูปภาพคอนเทนเนอร์ที่ประกอบด้วยคําแนะนําหรือเลเยอร์ที่จําเป็นสําหรับ Docker เพื่อสร้างคอนเทนเนอร์ที่ทํางานอยู่จากรูปภาพ ผลลัพธ์ของคําสั่งนี้คือรูปภาพ
`docker pull`	มีการเตรียมใช้งานคอนเทนเนอร์จากรูปภาพ ซึ่งดึงมาจากการลงทะเบียน เช่น Azure Container Registry รีจิสทรีนี้เป็นที่ที่บริการ Azure Kubernetes ดึงมา ผลลัพธ์ของคําสั่งนี้คือการดึงเครือข่ายของรูปภาพซึ่งเกิดขึ้นใน Azure อีกวิธีหนึ่งคือ คุณสามารถดึงรูปภาพภายในเครื่อง ตัวเลือกนี้เป็นเรื่องปกติเมื่อสร้างรูปภาพที่จําเป็นต้องมีการขึ้นต่อกันหรือเลเยอร์ที่แอปพลิเคชันของคุณอาจต้องการ เช่น เซิร์ฟเวอร์แอปพลิเคชัน
`docker run`	อินสแตนซ์ที่กําลังทํางานอยู่ของรูปภาพคือคอนเทนเนอร์ และคําสั่งนี้จะดําเนินการทุกเลเยอร์ที่จําเป็นสําหรับการเรียกใช้และโต้ตอบกับแอปพลิเคชันคอนเทนเนอร์ที่กําลังทํางานอยู่ ผลลัพธ์ของคําสั่งนี้คือกระบวนการแอปพลิเคชันที่ทํางานอยู่บนระบบปฏิบัติการโฮสต์
`docker push`	Azure Container Registry จะจัดเก็บรูปภาพเพื่อให้พร้อมใช้งานและอยู่ใกล้เคียงกับเครือข่ายสําหรับการปรับใช้และสเกล Azure

โคลนแอปพลิเคชัน Java

ก่อนอื่นลอกแบบที่เก็บการจองเที่ยวบินสําหรับการจองสายการบินและไปที่โฟลเดอร์โครงการแอปพลิเคชันเว็บของ Airlines

โน้ต

ถ้าการสร้างบริการ Azure Kubernetes เสร็จสิ้นในแท็บ CLI ของคุณ ให้ใช้แท็บนั้น หากยังคงทํางานอยู่ ให้เปิดแท็บใหม่และไปยังสถานที่ที่คุณต้องการโคลนระบบการจองเที่ยวบินสําหรับการจองของสายการบิน

เรียกใช้คําสั่งต่อไปนี้:

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

อีกวิธีหนึ่งคือ ถ้าคุณติดตั้ง Java และ Maven คุณสามารถเรียกใช้คําสั่งต่อไปนี้ในคอนโซลเทอร์มินัลเพื่อทําความเข้าใจเกี่ยวกับประสบการณ์การสร้างแอปพลิเคชันโดยไม่มี Docker ถ้าคุณไม่ได้ติดตั้ง Java และ Maven คุณสามารถดําเนินการต่อไปยังส่วนถัดไปสร้าง ไฟล์ Docker ได้อย่างปลอดภัย ในส่วนนั้น คุณใช้ Docker เพื่อดึง Java และ Maven ลงเพื่อดําเนินการบิลด์ในนามของคุณ

mvn clean package

โน้ต

เราใช้ mvn clean package คําสั่งเพื่อแสดงให้เห็นถึงความท้าทายในการดําเนินงานที่ไม่ได้ใช้รุ่น Multistage ของ Docker ซึ่งเราจะกล่าวถึงต่อไป อีกครั้ง ขั้นตอนนี้เป็นทางเลือก ไม่ว่าจะด้วยวิธีใด คุณสามารถดําเนินการอย่างปลอดภัยโดยไม่ต้องดําเนินการคําสั่ง Maven

หากกระบวนการนี้ประสบความสําเร็จ Maven สร้างระบบการจองเที่ยวบินสําหรับสายการบินสํารองแอปพลิเคชันเว็บ Archiveifact AirlinesReservationSample-0.0.1-SNAPSHOT.war ดังที่แสดงในผลลัพธ์ต่อไปนี้:

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

สมมติว่าคุณเป็นนักพัฒนา Java และคุณเพิ่งสร้าง AirlinesReservationSample-0.0.1-SNAPSHOT.war ขั้นตอนถัดไปของคุณอาจจะทํางานร่วมกับวิศวกรการดําเนินงานเพื่อปรับใช้สิ่งประดิษฐ์นี้ไปยังเซิร์ฟเวอร์ภายในองค์กรหรือเครื่องเสมือน เพื่อให้แอปพลิเคชันเริ่มต้นและเรียกใช้ได้สําเร็จ จะต้องมีเซิร์ฟเวอร์และเครื่องเสมือนพร้อมใช้งานและกําหนดค่าด้วยการอ้างอิงที่จําเป็น กระบวนการนี้ท้าทายและใช้เวลานาน โดยเฉพาะอย่างยิ่งตามความต้องการเมื่อโหลดที่เพิ่มขึ้นกําลังกระทบกับแอปพลิเคชันของคุณ ด้วยคอนเทนเนอร์ ความท้าทายเหล่านี้จะบรรเทาลงได้

สร้าง Dockerfile

ตอนนี้คุณพร้อมที่จะสร้าง Dockerfile แล้ว Dockerfile เป็นเอกสารข้อความที่มีคําสั่งทั้งหมดที่ผู้ใช้จะดําเนินการบนบรรทัดคําสั่งเพื่อประกอบรูปภาพคอนเทนเนอร์ แต่ละรูปภาพเป็นเลเยอร์ที่สามารถแคชเพื่อประสิทธิภาพได้ เลเยอร์สร้างขึ้นอยู่ด้านบนของกันและกัน

ตัวอย่างเช่น ระบบการจองเที่ยวบินสําหรับการจองของสายการบินจําเป็นต้องปรับใช้และเรียกใช้ภายในเซิร์ฟเวอร์แอปพลิเคชัน เซิร์ฟเวอร์แอปพลิเคชันไม่ได้รวมอยู่ภายใน AirlinesReservationSample-0.0.1-SNAPSHOT.war ซึ่งเป็นการขึ้นต่อกันภายนอกที่จําเป็นสําหรับ AirlinesReservationSample-0.0.1-SNAPSHOT.war เพื่อเรียกใช้ ฟัง และประมวลผลคําขอ HTTP จัดการเซสชันผู้ใช้ และอํานวยความสะดวกในการจองเที่ยวบิน หากคุณใช้การปรับใช้แบบดั้งเดิมซึ่งไม่ได้บรรจุวิศวกรการดําเนินงานจะติดตั้งและกําหนดค่าเซิร์ฟเวอร์แอปพลิเคชันบนเซิร์ฟเวอร์จริงหรือเครื่องเสมือนบางเครื่องก่อนที่จะปรับใช้ AirlinesReservationSample-0.0.1-SNAPSHOT.war วิศวกรการดําเนินงานเหล่านี้จะต้องตรวจสอบให้แน่ใจว่า JDK ถูกใช้บนเครื่องของคุณซึ่งเป็นสิ่งที่ mvn clean package ใช้เพื่อรวบรวมไฟล์ WAR อันที่จริงแล้วสอดคล้องกับ JRE เดียวกันที่ใช้โดยเซิร์ฟเวอร์แอปพลิเคชัน การจัดการการขึ้นต่อกันเหล่านี้เป็นเรื่องท้าทายและใช้เวลานาน

ด้วย Dockerfile คุณสามารถเขียนคําแนะนําหรือเลเยอร์ที่จําเป็นเพื่อให้บรรลุเป้าหมายนี้โดยอัตโนมัติโดยการวางเลเยอร์ในขั้นตอนที่จําเป็นเพื่อให้แน่ใจว่าระบบการจองเที่ยวบินสําหรับการจองสายการบินต้องมีการขึ้นต่อกันทั้งหมดที่จําเป็นเพื่อปรับใช้กับรันไทม์คอนเทนเนอร์ Docker โซลูชันนี้น่าสนใจเมื่อคุณทํางานกับมาตราส่วนตามความต้องการในช่วงเวลาที่ไม่ได้วางแผนไว้ แต่ละเลเยอร์ใช้แคช Docker ซึ่งประกอบด้วยสถานะของรูปภาพคอนเทนเนอร์ในแต่ละหลักเป้าหมายการเรียนการสอน ซึ่งปรับเวลาการคํานวณและนํากลับมาใช้ใหม่ หากเลเยอร์ไม่เปลี่ยนแปลง เลเยอร์ที่แคชไว้จะถูกใช้ กรณีการใช้งานทั่วไปสําหรับเลเยอร์ที่แคชไว้คือรันไทม์ Java เซิร์ฟเวอร์แอปพลิเคชัน และการขึ้นต่อกันอื่น ๆ สําหรับแอปพลิเคชันเว็บการจองเที่ยวบินสําหรับการจองเที่ยวบิน หากและเมื่อมีการเปลี่ยนแปลงเวอร์ชันบนเลเยอร์ที่แคชไว้ก่อนหน้านี้รายการใหม่ที่แคชไว้จะถูกสร้างขึ้น

แผนภาพต่อไปนี้แสดงเลเยอร์ของรูปภาพคอนเทนเนอร์ เมื่อดําเนินการคําสั่งใน Dockerfile เลเยอร์จะถูกสร้างขึ้น เลเยอร์บนสุดคือระบบการจองเที่ยวบินที่อ่าน/เขียนสําหรับชั้นเว็บแอปพลิเคชันการจองสายการบิน เลเยอร์นั้นถูกสร้างขึ้นที่ด้านบนของเลเยอร์แบบอ่านอย่างเดียวก่อนหน้านี้

Docker มีแนวคิดของรุ่นมัลติสเตจ ซึ่งเป็นคุณลักษณะที่ช่วยให้คุณสามารถสร้างภาพคอนเทนเนอร์ที่มีขนาดเล็กกว่าด้วยการแคชที่ดีขึ้นและฟุตพริ้นท์ความปลอดภัยที่เล็กลงทําให้การเพิ่มประสิทธิภาพและการบํารุงรักษา Dockerfile เพิ่มขึ้นเมื่อเวลาผ่านไป ตัวอย่างเช่น คุณสามารถแยกขั้นตอนการสร้างคอนเทนเนอร์สําหรับการคอมไพล์และสร้างแอปพลิเคชันจากขั้นตอนสําหรับการเรียกใช้แอปพลิเคชัน คุณลักษณะนี้ช่วยให้คุณสามารถคัดลอกเฉพาะวัตถุที่สร้างขึ้นในระหว่างการสร้างไปยังรูปภาพคอนเทนเนอร์การผลิตซึ่งจะลดรอยเท้า เนื่องจากรูปภาพคอนเทนเนอร์ถูกแคชไว้ หากไม่มีการเปลี่ยนแปลง คุณสามารถนํารูปภาพที่แคชไว้กลับมาใช้ใหม่ได้ ซึ่งจะช่วยลดค่าใช้จ่ายและเวลาของการดาวน์โหลดจากเครือข่าย

บริการที่เปิดเผยในสภาพแวดล้อมการผลิตต้องได้รับการจัดการอย่างรอบคอบเพื่อความปลอดภัย ดังนั้น สภาพแวดล้อมการผลิตใช้ และดําเนินการรูปภาพคอนเทนเนอร์ที่ปลอดภัย ตัวอย่างนี้ใช้รูปภาพที่ให้ CBL-Mariner มาโดย Microsoft

CBL-Mariner Linux เป็นระบบปฏิบัติการน้ําหนักเบา ซึ่งมีเฉพาะแพคเกจที่จําเป็นสําหรับสภาพแวดล้อมระบบคลาวด์เท่านั้น คุณสามารถปรับแต่งได้ผ่านแพคเกจแบบกําหนดเองและเครื่องมือเพื่อให้พอดีกับความต้องการของแอปพลิเคชันของคุณ CBL-Mariner ผ่านการทดสอบการตรวจสอบความถูกต้องของ Azure และเข้ากันได้กับตัวแทน Azure Microsoft สร้างและทดสอบ CBL-Mariner เพิ่มประสิทธิภาพให้กับกรณีการใช้งานต่าง ๆ ตั้งแต่บริการ Azure ไปจนถึงโครงสร้างพื้นฐาน IoT ซึ่งเป็นการกระจาย Linux ที่แนะนําภายในสําหรับการใช้งานกับบริการคลาวด์ของ Microsoft และผลิตภัณฑ์ที่เกี่ยวข้อง

โน้ต

Microsoft มีรูปภาพคอนเทนเนอร์ที่มาพร้อมกับ OpenJDK รวมถึงUbuntuCBL-Marinerรูปภาพ , และdistroless รูปภาพ distroless มีขนาดรูปภาพที่เล็กที่สุด แต่การเรียกใช้ Tomcat บนรูปภาพนั้นเป็นเรื่องที่ท้าทาย เพื่อให้ได้การออกแบบที่มีน้ําหนักเบา รูปภาพจะ distroless ลบคําสั่งและเครื่องมือมากมายรวมถึงเชลล์ซึ่งหมายความว่าคุณไม่สามารถเรียกใช้ catalina.sh เพื่อเริ่ม Tomcat ได้ รูปภาพ distroless นี้เหมาะสําหรับใช้งาน JAR ที่ใช้งานได้เช่นที่ใช้กับ Spring Boot หรือ Quarkus

ในตัวอย่างต่อไปนี้ เวอร์ชันเดียวกันของ Microsoft Build ของ OpenJDK จะใช้ในทั้งขั้นตอนการสร้างและขั้นตอนสุดท้าย วิธีนี้ช่วยให้แน่ใจว่าคุณสร้างโค้ดต้นฉบับด้วย JDK เวอร์ชันเดียวกันที่ Tomcat ปรับใช้บริการซึ่งจะช่วยหลีกเลี่ยงลักษณะการทํางานที่ไม่คาดคิดเนื่องจากเวอร์ชันไม่ตรงกัน

รูปภาพต่อไปนี้แสดงถึงรุ่นหลายขั้นตอนและสิ่งที่เกิดขึ้นในแต่ละขั้นตอนโดยยึดตามคําสั่งที่ระบุใน Dockerfile:

ในลําดับขั้นที่ 0 Tomcat จะถูกดาวน์โหลดและแยกลงในไดเรกทอรีที่ระบุโดยตัวแปรสภาพแวดล้อมบนรูปภาพ Ubuntu ตัวแปร TOMCAT_VERSION ระบุเวอร์ชันของ Tomcat ที่จะดาวน์โหลด หากมีการเผยแพร่ Tomcat เวอร์ชันใหม่ คุณควรอัปเดตหมายเลขเวอร์ชันเนื่องจากรูปภาพใหม่จะถูกดึงข้อมูลเมื่อหมายเลขเวอร์ชันมีการเปลี่ยนแปลงเท่านั้น มิฉะนั้น จะใช้รูปภาพที่แคชไว้ Tomcat ที่ดาวน์โหลดจะถูกคัดลอกไปยังสภาพแวดล้อมขั้นสุดท้ายสําหรับการใช้งาน

ในลําดับขั้นที่ 1 Maven ถูกติดตั้งบนรูปภาพ Ubuntu และไฟล์ต้นฉบับและการกําหนดค่าที่สร้างขึ้นจะถูกคัดลอกก่อนสร้างโครงการ Maven แต่ละเลเยอร์จะถูกแคชดังนั้นภาพ OS และเลเยอร์ภาพ Maven นําแคชกลับมาใช้ใหม่ หากมีการอัปเดตไฟล์การกําหนดค่าไฟล์ซอร์สโค้ดหรือไดเรกทอรีเว็บเลเยอร์จากการเปลี่ยนแปลงต่อไปจะถูกสร้างขึ้นใหม่ หากบิลด์เสร็จสมบูรณ์โดยไม่มีข้อผิดพลาดในระหว่างการคอมไพล์ วัตถุที่ชื่อว่า AirlinesReservationSample-0.0.1-SNAPSHOT.war จะถูกสร้างขึ้นภายใต้ไดเรกทอรีเป้าหมาย สิ่งประดิษฐ์นี้จะถูกคัดลอกไปยังสภาพแวดล้อมขั้นสุดท้ายสําหรับการใช้งาน

ในขั้นตอนสุดท้าย รูปภาพที่ปลอดภัย CBL-Mariner ที่ Microsoft ให้มาใช้เพื่อคัดลอกอาร์ติแฟกตของรุ่น Tomcat และ Java จากลําดับขั้นที่ 0 และลําดับขั้นที่ 1 ตามลําดับ ผู้ใช้ที่ app ชื่อเป็นเจ้าของไฟล์ทั้งหมดที่ใช้ภายในโครงการ และแอปพลิเคชันยังทํางานเป็น app ผู้ใช้แทนที่มีสิทธิ์ root พิเศษ การตั้งค่านี้ช่วยให้มั่นใจได้ว่ารูปภาพคอนเทนเนอร์สามารถทํางานได้อย่างปลอดภัยโดยไม่ต้องให้สิทธิ์ที่ไม่จําเป็น ในตอนท้าย หมายเลขพอร์ต 8080 จะแสดงและ สคริปต์ catalina.sh จะดําเนินการเพื่อเริ่มต้น Tomcat เมื่อเรียกใช้บน Docker Desktop ภายในเครื่องของคุณ คุณสามารถเข้าถึงได้ผ่านทาง URL http://localhost:8080/AirlinesReservationSample

ภายในโฟลเดอร์รากของโครงการของคุณ containerize-and-deploy-java-app-to-Azure/Project/Airlines ใช้คําสั่งต่อไปนี้เพื่อสร้างไฟล์ชื่อ Dockerfile:

vi Dockerfile

เพิ่มเนื้อหาต่อไปนี้ลงใน Dockerfile ของคุณ จากนั้นบันทึกและออก เมื่อต้องการบันทึกและออก ให้กด ESC ให้พิมพ์ :wq! แล้วกด 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"]

โน้ต

อีกทางหนึ่งคือ คุณสามารถใช้ไฟล์ Dockerfile_Solution ในรากของโครงการของคุณ ซึ่งประกอบด้วยเนื้อหาที่คุณต้องการ

Dockerfile จะแบ่งออกเป็นสามขั้นตอน ซึ่งจะอธิบายไว้ในตารางต่อไปนี้:

ขั้นตอนการติดตั้ง Tomcat:

คําสั่ง Docker	คำอธิบาย
`FROM`	`FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS tomcat`ตั้งค่ารูปพื้นฐานเป็น Microsoft Build ของ OpenJDK 17 บน Ubuntu และตั้งชื่อขั้นตอนนี้`tomcat` นี่คือตําแหน่งที่ติดตั้ง Tomcat
`ENV`	`ENV CATALINA_HOME=/usr/local/tomcat` ตั้งค่าตัวแปรสภาพแวดล้อมสําหรับไดเรกทอรีการติดตั้ง Tomcat
`ENV`	`ENV TOMCAT_VERSION=10.1.33` ตั้งค่ารุ่นของ Tomcat ที่จะติดตั้ง ซึ่งควรได้รับการอัปเดตเป็นเวอร์ชันล่าสุดตามความจําเป็น
`RUN`	คําสั่ง `RUN` จะอัปเดตรายการแพคเกจ ติดตั้ง `curl`ดาวน์โหลดเวอร์ชันที่ระบุของ Tomcat แยก ย้ายไปยังไดเรกทอรีที่ระบุ และล้างไฟล์และแพคเกจที่ไม่จําเป็น ซึ่งทําให้แน่ใจว่าภาพยังคงมีน้ําหนักเบา

ขั้นตอนการสร้างซึ่งคอมไพล์ด้วย Java 17:

คําสั่ง Docker	คำอธิบาย
`FROM`	`FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS build`ตั้งค่ารูปพื้นฐานเป็น Microsoft Build ของ OpenJDK 17 บน Ubuntu และตั้งชื่อขั้นตอนนี้`build` ลําดับขั้นนี้ใช้สําหรับคอมไพล์แอปพลิเคชัน Java
`WORKDIR`	`WORKDIR /build` ตั้งค่าไดเรกทอรีการทํางานภายในคอนเทนเนอร์เป็น `/build`ที่คัดลอกและคอมไพล์โค้ดต้นทาง
`RUN`	`RUN apt-get update && apt-get install -y maven && mvn --version` ติดตั้ง Maven เครื่องมือสร้างอัตโนมัติที่ใช้สําหรับโครงการ Java และตรวจสอบการติดตั้ง
`COPY`	`COPY pom.xml .` คัดลอกไฟล์การกําหนดค่า Maven ลงในไดเรกทอรีที่ทํางาน ไฟล์นี้จําเป็นสําหรับการสร้างโครงการ
`COPY`	`COPY src ./src` คัดลอกไดเรกทอรีซอร์สโค้ดลงในคอนเทนเนอร์ นี่คือที่ที่มีรหัสแอปพลิเคชัน Java
`COPY`	`COPY web ./web` คัดลอกไดเรกทอรีทรัพยากรบนเว็บลงในคอนเทนเนอร์ ซึ่งรวมถึงทรัพยากรของแอปพลิเคชันบนเว็บที่จําเป็นสําหรับการสร้าง
`RUN`	`RUN mvn clean package` ดําเนินการกระบวนการสร้าง Maven ซึ่งรวบรวมแอปพลิเคชัน Java และแพคเกจลงในไฟล์ WAR

ขั้นตอนสุดท้ายของแพคเกจ:

คําสั่ง Docker	คำอธิบาย
`FROM`	`FROM mcr.microsoft.com/openjdk/jdk:17-mariner` ตั้งค่ารูปพื้นฐานเป็น Microsoft Build ของ OpenJDK 17 บน `CBL-Mariner`ซึ่งใช้สําหรับการปรับใช้ขั้นสุดท้ายของแอปพลิเคชัน
`ENV`	`ENV CATALINA_HOME=/usr/local/tomcat` ตั้งค่าตัวแปรสภาพแวดล้อมสําหรับไดเรกทอรีการติดตั้ง Tomcat ซึ่งคล้ายกับขั้นตอนการติดตั้ง
`ENV`	`ENV PATH=$CATALINA_HOME/bin:$PATH` เพิ่มไดเรกทอรี Bin ของ Tomcat ในระบบ `PATH`เพื่อให้สามารถเรียกใช้คําสั่ง Tomcat ได้อย่างง่ายดาย
`USER`	`USER app` ระบุผู้ใช้ที่กระบวนการ Tomcat ทํางาน เพิ่มความปลอดภัยโดยการไม่เรียกใช้เป็นผู้ใช้ระดับสูง
`COPY`	`COPY --chown=app:app --from=tomcat ${CATALINA_HOME} ${CATALINA_HOME}` คัดลอกการติดตั้ง Tomcat จาก `tomcat` ขั้นตอน การตั้งค่าความเป็นเจ้าของให้กับ `app` ผู้ใช้
`COPY`	`COPY --chown=app:app tomcat-users.xml ${CATALINA_HOME}/conf` คัดลอกไฟล์การกําหนดค่าผู้ใช้ Tomcat ลงในคอนเทนเนอร์ ตั้งค่าความเป็นเจ้าของให้กับ `app` ผู้ใช้
`COPY`	`COPY --chown=app:app --from=build /build/target/.war ${CATALINA_HOME}/webapps/AirlinesReservationSample.war` คัดลอกไฟล์ WAR ที่ถูกคอมไพล์จาก `build` ขั้นตอนไปยังไดเรกทอรี เว็บแอป* Tomcat ตั้งค่าความเป็นเจ้าของให้กับ `app` ผู้ใช้
`EXPOSE`	`EXPOSE 8080` แสดงพอร์ต 8080 ซึ่งเป็นพอร์ตเริ่มต้นสําหรับ Tomcat เพื่อให้สามารถเข้าถึงแอปพลิเคชันภายนอกได้
`CMD`	`CMD ["catalina.sh", "run"]` ระบุคําสั่งเพื่อเริ่ม Tomcat เมื่อเรียกใช้คอนเทนเนอร์

สําหรับข้อมูลเพิ่มเติมเกี่ยวกับการสร้าง Dockerfile ให้ดู การอ้างอิง Dockerfile

คำติชม

หน้านี้มีประโยชน์หรือไม่