สร้าง Container แบบกำหนดเอง

วัตถุประสงค์

บทความนี้อธิบายการใช้งาน สร้าง Container แบบกำหนดเอง บน Ruk-Com Cloud PaaS โดยจัดลำดับขั้นตอนและจุดตรวจสอบสำหรับการนำไปใช้งานจริง

ก่อนเริ่มดำเนินการ

• เข้าสู่ระบบด้วยบัญชีที่มีสิทธิ์จัดการ Environment ที่เกี่ยวข้อง
• ตรวจสอบชื่อ Environment, Region และ Resource เป้าหมายก่อนบันทึกการเปลี่ยนแปลง
• สำรองข้อมูลหรือกำหนดแผนย้อนกลับก่อนแก้ไขระบบ Production

การดำเนินการเตรียม Docker image ของคุณจะง่ายขึ้นด้วย Ruk-Com Cloud โดยสร้างจากพื้นฐานเดิมที่มีอยู่แล้ว (กล่าวคือ - Template พื้นฐาน CentOS 7) ทำให้สามารถข้ามขั้นตอนทั้งหมดที่เสร็จแล้วภายใน Template "parent" และเพิ่มการปรับเปลี่ยนที่คุณต้องการเท่านั้น เราจะพิจารณาขั้นตอนการเตรียม WildFly image แบบกำหนดเองด้วย - Java application server ที่ยืดหยุ่นและน้ำหนักเบาซึ่งเป็นตัวต่อโดยตรงของ JBoss

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

ด้านล่างนี้ เราจะอธิบายข้อมูลจำเฉพาะทั้งหมดของ image แบบกำหนดเองที่ทำงานบน Platform ของเรา และด้วยเหตุนี้คุณจะได้ WildFly server เวอร์ชั่นเทียบท่าที่พร้อมใช้งานได้ทันทีภายใน Platform

ดังนั้นมาดูการดำเนินการที่จำเป็นทีละขั้นตอน:

• กำลังเขียน dockerfile
• การเพิ่ม Image ลงในพื้นที่เก็บข้อมูล
• การ DeployImage ที่ Ruk-Com PaaS

กำลังเขียน Dockerfile

เริ่มต้นด้วยการสร้างไฟล์เปล่า - ประกาศการดำเนินการที่เหมาะสมทั้งหมดในไฟล์นั้นโดยตรงและดำเนินการตามคำแนะนำต่อไปนี้

หมายเหตุ: ส่วนนี้เป็นการสำรวจลักษณะและพื้นฐานที่จำเป็นต่อ Dockerfile ของคุณอย่างไรก็ตามหากต้องการเจาะลึกถึงข้อมูลจำเพาะของการดำเนินการและรับรายละเอียด/คำแนะนำเพิ่มเติม คุณสามารถหาข้อมูลอ้างอิงจากเว็บไซต์ของDocker ไฟล์ที่เป็นทางการได้

นอกจากนี้คุณสามารถดาวน์โหลด dockerfile ที่เตรียมไว้ล่วงหน้าแล้ว (ด้วยตัวอย่าง WildFly image) ในส่วนต่อไปจะเป็นการอธิบายการดำเนินการสร้างไฟล์ด้วยตนเอง

1. ขั้นตอนแรกคือการระบุ Template พื้นฐานสำหรับการสร้าง image โดยเราจะใช้ Ruk-Com PaaSdocker/Ruk-Com PaaS-centos7 ที่มีระบบปฏิบัติการเซนโอเอส 7ที่กำหนดค่าภายในไว้แล้ว การตั้งค่าภายใน dockerfile ควรใช้คำสั่งจาก:

FROM jelasticdocker/jelastic-centos7-base:latest

2. ขั้นตอนที่สองคุณสามารถระบุข้อมูล image ทั่วไป (เช่น metadata หรือ variables) ซึ่งจะจำเป็นในระหว่างการกำหนดค่าเพิ่มเติม คุณสามารถดูตัวอย่างด้านล่างเพื่อตั้งค่าที่จำเป็น:

LABEL maintainer="RukComCloud,Inc"
ENV WILDFLY_VERSION 13.0.0.Final

ENV ADMIN_USER rukcomcloud

ENV ADMIN_PASSWORD rukcomcloud

โดยที่:

• LABEL - อนุญาตให้คุณตั้งค่า image metadata ผ่านคู่ key-value ที่เหมาะสม (เช่น ผู้สร้าง Docker image, version)
• ENV - ตั้งค่าตัวแปร environment หลักเช่น
• WILDFLY_VERSION - เวอร์ชั่นของ WildFly ที่จะสร้าง; สามารถเปลี่ยนเป็นเวอร์ชั่นอื่นได้ หากจำเป็น(ลิสเวอร์ชั่นปัจจุบันที่มีอยู่และสามารถใช้งานได้)
• ADMIN_USER - ชื่อผู้ดูแลระบบสำหรับการเข้าถึงแผงควบคุม WildFly ในภายหลัง
• ADMIN_PASSWORD - ระบุรหัสผ่านที่ต้องการ

3. ตอนนี้คุณสามารถประกาศการกำหนดค่าที่จำเป็นโดยใช้ shell command - ใช้วิ่งเพื่อดำเนินการสำหรับจุดประสงค์นี้
ก่อนอื่น คุณต้องติดตั้ง Java Development Kit (ในกรณีของเรา OpenJDK version 8) และเอกสารสำคัญทาร์(ใช้ในการขยายข้อมูลไฟล์ที่ดาวน์โหลด)

RUN yum -y install java-1.8.0-openjdk-devel tar && yum -y update;

คำสั่งนี้ลงท้ายด้วยการเรียกการอัปเดตทั่วไปของ Package ที่ติดตั้งไว้

4. ต่อไปเป็นส่วนของการประกาศการดำเนินการเพิ่มเติมสำหรับการดาวน์โหลด WildFly source code จากเว็บไซต์ทางการและแตกไฟล์ไปยัง /opt โฟลเดอร์

RUN cd /opt && curl -O https://download.jboss.org/wildfly/${WILDFLY_VERSION}/wildfly-${WILDFLY_VERSION}.tar.gz \
&& $(which tar) xf wildfly-${WILDFLY_VERSION}.tar.gz \
&& rm wildfly-${WILDFLY_VERSION}.tar.gz

5. ขั้นตอนที่ห้าคุณต้องสร้าง symlink เพื่อย่อเส้นทางไปยัง directory หลักของ WildFly และทำให้สามารถเข้าถึงได้ง่ายขึ้น

RUN ln -s /opt/wildfly-$WILDFLY_VERSION /opt/wildfly

6. จากนั้นดำเนินการสร้างการกำหนดค่าไฟล์หลักสำหรับ WildFly server และใส่ตัวเลือกที่จำเป็นทั้งหมดลงไป

RUN echo -en "JAVA_HOME=\"/usr/lib/jvm/java\""'\n'\
"JBOSS_HOME=\"/opt/wildfly\""'\n'\
"JBOSS_USER=wildfly"'\n'\
"JBOSS_MODE=standalone"'\n'\
"JBOSS_CONFIG=standalone.xml"'\n'\
"STARTUP_WAIT=60"'\n'\
"SHUTDOWN_WAIT=60"'\n'\
"JBOSS_CONSOLE_LOG=\"/var/log/wildfly/console.log\""'\n'\
"JBOSS_OPTS=\"-b 0.0.0.0 -bmanagement=0.0.0.0 -Djboss.management.http.port=4949 -Djboss.management.https.port=4848\"" >> /etc/default/wildfly

7. CentOS 7 เริ่มต้นใช้งานโดยใช้ Script Systemd ซึ่งเป็นค่าเริ่มต้นแต่ Server WildFly ต้องการ SystemV ขั้นต้นแบบดั้งเดิมมากกว่า ดังนั้นคุณต้องคัดลอก initscript เริ่มต้นไปยังโฟลเดอร์ /etc/init.d และแก้ไขการกำหนดค่าที่เหมาะสมเพื่อหลีกเลี่ยง systemd เปลี่ยนเส้นทาง

RUN wget https://raw.githubusercontent.com/wildfly/wildfly-core/master/core-feature-pack/src/main/resources/content/docs/contrib/scripts/init.d/wildfly-init-redhat.sh -O /etc/rc.d/init.d/wildfly;
sed -i "/# Source function library/a\SYSTEMCTL_SKIP_REDIRECT=1" /etc/init.d/wildfly; chmod +x /etc/init.d/wildfly;

8. ต่อไปเราจะระบุให้ WildFly ทำงานเมื่อเริ่มต้น Container โดยเพิ่มผู้ใช้ระบบที่เกี่ยวข้องและเปลี่ยนแปลงสิทธิการครอบครองไฟล์

RUN chkconfig --add wildfly; chkconfig wildfly on; mkdir -p /var/log/wildfly; adduser wildfly;
chown -R wildfly:wildfly /opt/wildfly-$WILDFLY_VERSION /opt/wildfly /var/log/wildfly;

9. นอกจากนั้นคุณสามารถเพิ่มข้อมูลรับรองผู้ใช้งาน โดยเราได้กำหนดไว้แล้วในขั้นตอนแรกสำหรับการเข้าถึงแผงควบคุม Server ของผู้ดูแล

RUN /opt/wildfly/bin/add-user.sh --user $ADMIN_USER --password $ADMIN_PASSWORD --silent --enable

10. ตอนนี้เราสามารถ link ไปยังแผงควบคุมของผู้ดูแลระบบได้อย่างถูกต้องที่หน้า index.html โดยกำหนดการเปลี่ยนเส้นทางที่สอดคล้องกัน (เช่น ในกรณี image ของเราจะถูกนำไปใช้กับ Container โดยไม่ต้องแนบ IP ภายนอก port 4949 และการเชื่อมต่อ HTTP)

RUN sed -i "s/<a href=\"\/console\">/<a href=\"\/console\" onclick=\"javascript:event.target.port=4949;event.target.protocol=\'http:\';\">/" /opt/wildfly/welcome-content/index.html

11. เพิ่มการตั้งค่า localeภาษาอังกฤษลงใน Container

RUN localedef -i en_US -f UTF-8 en_US.UTF-8

12. การดำเนินการที่จำเป็นอีกประการหนึ่งคือการตั้งค่า Docker image ของเราให้ฟัง ports ที่จำเป็นขณะใช้งานโดยใช้คำสั่งเปิดเผย

EXPOSE 22 80 443 8080 8743 9990 9993 8009 4848 4949

13. ขั้นตอนสุดท้ายคุณต้องตั้งค่าจุดเริ่มต้นเพื่อกำหนด Container ให้รันเป็นแบบสั่งการให้ทำงานได้ ในกรณีของเราควรระบุ bash shell

ENTRYPOINT ["/bin/bash"]

และนี่คือทั้งหมด อย่าลืมบันทึกการตั้งค่าที่ประกาศไว้ทั้งหมดเพื่อรับ dockerfile ที่พร้อมใช้งาน

การเพิ่ม Image ไปยังพื้นที่เก็บข้อมูล

เมื่อจัดเตรียมไฟล์ dockerfile ที่เหมาะสมเสร็จแล้วคุณก็พร้อมที่จะสร้าง WildFly image ตามลำดับและ push ไปยังที่จัดเก็บ

หมายเหตุ:ก่อนเริ่มต้น คุณต้องตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง Docker CE เวอร์ชั่นที่เหมาะสมแล้ว (ตามประเภทของระบบปฏิบัติการที่ใช้) เพื่อดำเนินการติดตั้งด้วยคำสั่งสำหรับเครื่องที่ใช้อยู่ในปัจจุบันตามคำอธิบายด้านล่างนี้

ดังนั้น ทำตามขั้นตอนต่อไปนี้:

1. Run คำสั่งสร้าง Dockerด้วย Parameter ที่จำเป็นเพื่อสร้าง image ใหม่ในเครื่องของคุณ:
   

sudo docker build -t {image_name} {dockerfile_location}

โดยที่:

• {Image_ชื่อ}- ชื่อที่เก็บภาพ; หรือจะเพิ่มแท็กเวอร์ชั่หลังตัวคั่น ":" (เช่น rukcom/wildfly:latest)
• {Dockerfile_location}- local path หรือ URL ไปยัง dockerfile ของคุณ (สามารถตั้งค่าเป็น "." หากไฟล์นั้นอยู่ใน directory ปัจจุบัน)

2. คุณจะได้รับข้อความเมื่อสร้างสำเร็จพร้อมทั้ง image ID ใหม่เพื่อรับรองว่า workstation ของคุณพร้อมใช้งานและคุณสามารถดูรายการ Template ในเครื่องทั้งหมดได้ด้วยคำสั่ง:

sudo docker images

3. ในตอนท้ายคุณต้อง push (อัปโหลด) image ของคุณไปยัง registry ด้วยคำสั่งที่เกี่ยวข้อง:

sudo docker push {image_name}

ในตัวอย่างนี้ควรระบุ{Image_ชื่อ}ชื่อเดียวกับที่คุณระบุไว้ในระหว่างการสร้าง image ขั้นตอนที่ 1

คุณจะได้รับการร้องขอคำขอเพิ่มเติมเพื่อยืนยันว่าคุณเป็นเจ้าของบัญชี (โดยการระบุชื่อผู้ใช้ รหัสผ่านและที่อยู่อีเมลที่เกี่ยวข้อง) เพื่อให้การดำเนินการนี้เสร็จสมบูรณ์

เคล็ดลับ:คุณสามารถเข้าสู่ระบบ registry ล่วงหน้าได้โดยใช้คำสั่ง docker เข้าสู่ระบบ (ด้วยเหตุนี้ข้อมูลส่วนตัวของคุณจะถูกเก็บไว้ในไฟล์~ /.Docker/กำหนดค่า.jsonที่ home directory ในเครื่องของคุณ

การ DeployImage ที่ RukCom Cloud

เมื่อ image ของคุณถูกจัดเก็บสำเร็จแล้วจะพร้อมใช้งานที่ RukCom Cloud platform และสามารถเพิ่ม environment เฉพาะที่ Docker board รวมเข้ากับส่วนของตัวช่วยสร้าง TopologyDashboard

ดันนั้นคลิกปุ่ม New Environment ที่ด้านบนของ Dashboard เลือกแท็บ Docker ภายใน environment wizard ที่เปิดอยู่และคลิก Select Image

1. คุณสามารถใช้แท็บ Search เพื่อค้นหา image เพิ่มเติมได้ที่ Docker Hub หรือย้อนกลับไปที่ส่วนเดิมเพื่อกำหนดเอง ซึ่งสามารถใช้งาน image ประเภทใดก็ได้ (รวมถึงแบบ private) โดยจะเก็บ Template ของคุณสำหรับการเข้าถึงที่ง่ายขึ้น

เมื่อคลิกเข้าไปแล้วให้เลือก environment layer ที่จำเป็นทางด้านซ้าย (กรณีของเราเลือก Application Servers) จากนั้นคลิกปุ่มเพิ่ม Image ใหม่

2. เพิ่ม image ใหม่โดยการระบุชื่อในช่องชื่อเช่น

{Registry_ชื่อ Host}(สามารถข้ามไปที่ Hub Registry อย่างเป็นทางการ)/{บัญชี}/{image_name}
นอกจากนี้ในการระบุที่จัดเก็บแบบส่วนตัวพื้นที่เก็บข้อมูลส่วนตัวควรระบุข้อมูลรับรอง username และ password ที่เหมาะสม

เราใช้ที่จัดเก็บแบบ Public ของ Docker Hub ซึ่งอยู่ภายใน Registry Hub ส่วนกลาง ดังนั้นจึงใช้เฉพาะชื่อที่เก็บเท่านั้นและคลิกเพิ่ม

3. หลังจากนั้น image ที่คุณเพิ่มจะปรากฏในรายการของคุณ เพียงแค่คลิกหนึ่งครั้งเพื่อเพิ่มไปยัง topology นอกจากนี้ Template นี้จะยังคงถูกจดจำและแสดงอยู่ในหน้านี้ซึ่งจะสามารถค้นหาได้ง่ายระหว่างการเลือก Container (หากคุณต้องการนำออก สามารถคลิกปุ่มไอคอนถังขยะเพื่อลบ)

ตั้งค่าส่วนที่เหลือสำหรับการกำหนดค่าที่จำเป็นด้วยตัวเองและสร้าง environment ให้เสร็จสิ้น (สามารถอ่านรายละเอียดการกำหนดค่าเพิ่มเติมได้ในคู่มือ) จากนั้นคลิกสร้าง

4. เมื่อ environment ของคุณกับ image ภายในที่เหมาะสมปรากฏบน Dashboard คุณสามารถเข้าถึงได้โดยคลิกปุ่มเปิดใน Browser

หมายเหตุ:ในกรณีที่คุณไม่ได้เลือก Template ลงใน App Server หรือ Balancing environment คุณจะต้องใช้ปุ่มที่มีชื่อเดียวกันถัดจาก Container เพื่อเปิด

ดังนั้นเมื่อเปิด Browser คุณจะเห็นหน้าเริ่มต้นของ WildFly ซึ่งหมายความว่าทุกอย่างได้รับการกำหนดค่าอย่างถูกต้องและ Container ที่สร้างขึ้นใหม่ทำงานได้อย่างสมบูรณ์