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

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

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

• composing dockerfile
• adding image to repository
• deploying image at Jelastic

Composing Dockerfile

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

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

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

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

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 – ใช้ RUN เพื่อดำเนินการสำหรับจุดประสงค์นี้
ก่อนอื่น คุณต้องติดตั้ง Java Development Kit (ในกรณีของเรา OpenJDK version 8) และเอกสารสำคัญ tar (ใช้ในการขยายข้อมูลไฟล์ที่ดาวน์โหลด)

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

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

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 เริ่มต้นใช้งานโดยใช้สคริปต์ Systemd ซึ่งเป็นค่าเริ่มต้นแต่เซิร์ฟเวอร์ 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 ทำงานเมื่อเริ่มต้นคอนเทนเนอร์ โดยเพิ่มผู้ใช้ระบบที่เกี่ยวข้องและเปลี่ยนแปลงสิทธิการครอบครองไฟล์

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. นอกจากนั้นคุณสามารถเพิ่มข้อมูลรับรองผู้ใช้งาน โดยเราได้กำหนดไว้แล้วในขั้นตอนแรกสำหรับการเข้าถึงแผงควบคุมเซิร์ฟเวอร์ของผู้ดูแล

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

10. ตอนนี้เราสามารถ link ไปยังแผงควบคุมของผู้ดูแลระบบได้อย่างถูกต้องที่หน้า index.html โดยกำหนดการเปลี่ยนเส้นทางที่สอดคล้องกัน (เช่น ในกรณี image ของเราจะถูกนำไปใช้กับคอนเทนเนอร์โดยไม่ต้องแนบ 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 ภาษาอังกฤษลงในคอนเทนเนอร์

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

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

EXPOSE 22 80 443 8080 8743 9990 9993 8009 4848 4949

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

ENTRYPOINT ["/bin/bash"]

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

Adding Image to Repository

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

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

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

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

sudo docker build -t {image_name} {dockerfile_location}

โดยที่:

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

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

sudo docker images

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

sudo docker push {image_name}

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

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

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

Deploying Image at RukCom Cloud

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

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

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

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

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

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

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

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

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

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

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

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

The post Building Custom Container appeared first on คู่มือการใช้งาน Ruk-Com Cloud (PAAS).

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

การจัดการ Docker image ด้วยตนเอง จำเป็นต้องมี registry ที่เหมาะสมโดย Dockerized solutions ส่วนใหญ่จะถูกเก็บไว้ใน registry สาธารณะเพื่อให้ทุกคนสามารถใช้งานได้ แต่อย่างไรก็ตามบางครั้งมีความจำเป็นต้องซ่อนเนื้อหาที่เก็บข้อมูลของคุณจากส่วนอื่นๆ เช่น ในกรณีที่มีรหัสเกี่ยวกับกรรมสิทธิ์หรือข้อมูลที่เป็นความลับ ซึ่งจุดประสงค์นี้คุณสามารถสร้าง registry ส่วนตัวแยกเองได้

ดังนั้นมาดูวิธีการทำที่ Ruk-Com Cloud Paltform เพียงใช้เวลาไม่กี่นาทีโดยทำตามขั้นตอนต่อไป:

• deploying private registry
• adding image to registry
  

หลังจากนั้นคุณสามารถ deploy image ที่เพิ่มจาก private registry ของคุณไปยัง Ruk-Com Cloud PaaS ได้อย่างง่ายดาย

Deploy Private Registry

เทมเพลตพื้นฐานสำหรับ private registry สามารถพบได้จาก open-source images ที่ Docker Hub ดังนั้นคุณสามารถทำการโฮสต์ภายในได้อย่างสะดวกสะบาย การติดตั้ง Ruk-Com Cloud สามารถกำหนดคอนเทนเนอร์ที่เหมาะสมเองได้:

1. เข้าสู่ระบบด้วยบัญชี Ruk-Com Cloud ของคุณและคลิกปุ่ม New Environment ที่ด้านบนของหน้าต่าง

เมื่อเปิด topology wizard ให้สลับไปที่แท็บ Docker จากนั้นคลิก Select Image

2. ใช้การค้นหาเพื่อหา image registry และเพิ่มเข้าไป

เคล็ดลับ: คุณสามารถเลือก tag ที่ต้องการสำหรับ Docker image ได้ที่ด้านบนของเฟรมนี้หรือระหว่างขั้นตอนถัดไป

3. การ configurations อื่นๆทั้งหมดสำหรับ environment (การจำกัด disk, ชื่อ, ภูมิภาค, และอื่นๆ) ตามความต้องการของคุณ

หมายเหตุ:
คำแนะนำด้านล่างนี้เหมาะสำหรับ registry เวอร์ชั่นใหม่ล่าสุด (เวอร์ชั่นที่เริ่มต้นด้วย tag 2.x ขึ้นไป) สำหรับ deprecated registries การกำหนดค่าและการทำงานร่วมกันอาจมีรายละเอียดที่แตกต่างกันไป

4. ตอนนี้คุณต้องกำหนดค่า entry point สำหรับการเข้าถึงจากภายนอก ซึ่งจะสร้างโดยใช้ Ruk-Com Cloud endpoints feature เพื่อที่จะเปิดเผยพอร์ตของคอนเทนเนอร์ 5000

เพิ่มเติม: อีกวิธีหนึ่งคุณสามารถแนบและทำงานผ่าน Public IP ได้ (ตัวเลือกที่ต้องชำระเงินเพิ่ม) โดยไม่ต้องกำหนดค่าใดๆเพิ่มเติม

คลิกที่ปุ่ม Setting ที่อยู่ถัดจาก environment ของคุณ จากนั้นเลือก Endpoints และกด Add เพื่อเพิ่ม enpoint ใหม่ภายในเฟรมที่เปิดอยู่ คุณสามารถใส่พารามิเตอร์ที่ต้องการโดยระบุหมายเลข private port 5000
ดังนั้นคุณจะได้รับผลลัพธ์คล้ายกับที่แสดงดังภาพด้านบนและตอนนี้คุณสามารถเริ่มเติม registry กับ Docker image ได้แล้ว

Add Image to Registry

การเพิ่ม Docker template ลงใน registry ของคุณสามารถทำได้โดยการนำ image ภายนอกจาก central hub registry ส่งไปยังที่จัดเก็บส่วนตัวของเรา private repository (อย่างไรก็ตามคุณสามารถดำเนินการเองได้ที่เครื่องของคุณ) โดยจะต้องทำการปรับเปลี่ยนการกำหนดค่าในเครื่องของคุณเล็กน้อย เพื่อให้สามารถใช้งานได้อย่างถูกต้อง

1 เริ่มต้นด้วยการติดตั้ง Docker CE (หากคุณยังไม่เคยทำมาก่อน) สามารถคลิกที่ลิงก์เพื่อดูคู่มือได้จากเว็บไซต์ที่เป็นทางการ

เพิ่มเติม: ตรวจสอบให้แน่ใจว่า daemon ที่ติดตั้งเป็นเวอร์ชั่น 1.6.0 หรือใหม่กว่า (เนื่องจาก registry จะไม่สามารถใช้งานร่วมกับเวอร์ชั่นก่อนหน้าได้) คุณสามารถตรวจสอบเวอร์ชั่น Docker daemon โดยรันคำสั่งต่อไปนี้ที่ terminal:

docker -v

2. จากนั้นเลือก image ที่คุณต้องการได้ที่ Docker Hub โดยใช้คำสั่ง pull และ tag เทมเพลตที่ได้รับเพื่อชี้ไปที่ private registry ของคุณเอง (หรือในกรณีของการใช้เทมเพลตในเครื่องของคุณ ให้ข้ามคำสั่งแรก)

docker pull {image} && docker tag {image} {entry_point}/{repository}

โดยที่:

• {image} – ชื่อของ Docker template ที่คุณต้องการดึงและแท็ก (เช่น rukcom/apachephp)
• {entry_point} – entry point ของ private registry เช่นปลายทาง endpoint (ถูกสร้างขึ้นที่ส่วนสุดท้าย Access URL) หรือที่อยู่ IP ภายนอก

• {repository} – ชื่อของที่จัดเก็บ private registry ระยะไกล (เช่น apachephp) สำหรับ image ที่จะจัดเก็บ

3. รายละเอียดเพิ่มเติม – ในขณะที่ private registry ระยะไกลจำเป็นต้องรักษาความปลอดภัยร่วมกับ registry ด้วย TLS และคุณต้องแนบไฟล์รับรอง SSL certificate ที่เกี่ยวข้อง (เช่น server key และ domain certificate) ที่ออกโดย CA ของ registry คุณ

เคล็ดลับ: สามารถใช้ใบรับรอง self-signed certificate ที่ลงนามเองได้เช่นเดียวกัน ในกรณีนี้คุณจะต้องสั่งให้ Docker daemon เชื่อถือด้วยตนเอง

อย่างไรก็ตาม สำหรับวัตถุประสงค์ของการทดสอบคุณสามารถใช้การกำหนดค่าที่ค่อนข้างง่ายกว่าซึ่งช่วยให้สามารถข้ามข้อกำหนดนี้ – run registry ของคุณในโหมดที่ไม่ปลอดภัย ดังนั้นการสื่อสารทั้งหมดจะดำเนินการผ่าน HTTP ธรรมดา (ถึงแม้ว่าจะไม่แนะนำอย่างมากในขอบเขตของการใช้งาน)
โดยเพิ่มบรรทัดนี้ใน configuration file /etc/default/docker ที่ daemon ของคุณ (หรือไฟล์ที่คล้ายกันตามการกระจาย OS ของคุณ) เช่น ใช้ vim เพื่อแก้ไขด้วยการอนุญาตจาก sudo:

DOCKER_OPTS="--insecure-registry  {entry_point}"

อย่าลืม Save เพื่อบันทึกการเปลี่ยนแปลง

หมายเหตุ: ในกรณีที่ใช้ self-signed certificate หรือตัวเลือกที่ไม่ปลอดภัยจำเป็นจะต้องกำหนดค่าเพิ่มเติมเพื่อนำไปใช้กับ Docker daemon ทุกตัวซึ่งจำเป็นต้องเข้าถึง registry ของคุณ

4. ตอนนี้คุณสามารถรีสตาร์ท Docker daemon ในเครื่องของคุณและ push image ที่เตรียมไว้ไปยังที่เก็บระยะไกลของคุณ

sudo service docker restart
docker push  {entry_point}/ {repository}

หลังจากนั้น image ของคุณจะถูกอัปโหลดไปยัง registry (ซึ่งเวลาจะขึ้นอยู่กับขนาดของรูปภาพและความเร็วของอินเตอร์เน็ต) และจะพร้อมใช้งานทั้งหมด
ด้วยเหตุนี้คุณจึงสามารถ deploy ได้อย่างง่ายดายภายใน Ruk-Com Cloud PaaS ในลักษณะเดียวกับคำแนะนำวิธีการใช้งานข้างต้น

ในกรณีที่คุณประสบปัญหาใดๆในระหว่างการ deploy registry ของคุณหรือเพิ่ม image คุณสามารถขอความช่วยเหลือจากผู้เชี่ยวชาญทางเทคนิคได้ที่ Stackoverflow

The post Private Registry inside Ruk-Com Cloud PaaS appeared first on คู่มือการใช้งาน Ruk-Com Cloud (PAAS).

• หมายเหตุ: การกำหนดค่าด้วย Ruk-Com Cloud ส่วนใหญ่สามารถทำได้โดยตรงผ่าน dashboard และไม่จำเป็นต่องใช้ SSH ด้วยเครื่องมือดังต่อไปนี้:
  
  
  • Container Configurations – ปรับแต่งคอนเทนเนอร์หลัก เช่น variables, volumes, linking, run options, ports และอื่นๆ
  • Configuration Manager – เข้าถึง root แบบเต็มไปยังระบบไฟล์ของคอนเทนเนอร์และอนุญาตให้ทำงานร่วมกับไฟล์ประกอบทั้งหมด
    
    
• นอกจากนี้คุณยังสามารถใช้ CLI client เฉพาะของ Ruk-Com Cloud เพื่อการจัดการระยะไกลขึ้นสำหรับ environments และ nodes ทุกประเภท อีกทั้งยังช่วยให้วงจรแอปพลิเคชั่นของคุณดำเนินการแบบอัตโนมัติผ่านสคริปต์
  
  

การเชื่อมต่อ SSH กับคอนเทนเนอร์มี 2 วิธีดังนี้:

• ผ่าน Ruk-Com Cloud Gateway เช่นเดียวกับ environment อื่นๆโดยสามารถทำได้ดังนี้:
  
  
  • การสร้าง SSH keypair
  • เพิ่ม Public SSH key ของคุณไปที่ dashboard
  • การเข้าถึงบัญชีของคุณผ่าน SSH protocol
    
    
• หรือหากคุณไม่ต้องการใช้ SSH keys คุณสามารถแนบที่อยู่ public IP กับ node ที่ต้องการและทำตามขั้นตอนต่อไปนี้:
  • เปิด terminal emulator
  • ป้อนสตริง ssh [username]@[hostname] โดย username คือชื่อผู้ใช้ที่คุณ login และ hostname คือที่อยู่ public IP (ที่คุณได้รับข้อมูลรับรองเหล่านี้ผ่านอีเมลทุกครั้งที่มีการสร้างหรือเพิ่มคอนเทนเนอร์/environment ใหม่)
  • ระบุ password ที่ร้องขอ (สามารถดูได้จากอีเมลเช่นกัน)

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

หมายเหตุ: หากคุณประสบปัญหาระหว่างสร้างการเชื่อมต่อคอนเทนเนอร์ ให้คุณตรวจสอบ firewall rules สำหรับคอนเทนเนอร์คุณเพื่อให้แน่ใจว่า openssh เซิร์ฟเวอร์กำลังทำงานอยู่

Reset Password

ในกรณีที่คุณลืมข้อมูลอ้างอิงคอนเทนเนอร์ของคุณ/สูญหาย/ลบอีเมล คุณสามารถทำการกู้คืนได้ตลอดเวลา – เพียงกดที่ไอคอนรูปเฟืองเลือก Reset password สำหรับ node ที่จำเป็น (หรือ set ของ node)

The post Custom Container SSH Access appeared first on คู่มือการใช้งาน Ruk-Com Cloud (PAAS).

บทความนี้จะกล่าวถึงหลักการทำงานที่สำคัญของแอปพลิเคชัน Docker ซึ่งอาจเป็นจุดสนใจสำหรับทั้งผู้เริ่มต้นและผู้พัฒนา

ในส่วนของด้านล่างนี้ จะเป็นข้อมูลเชิงลึกเกี่ยวกับวิธีการเชื่อมต่อคอนเทนเนอร์กับ Ruk-Com Cloud โดยพิจารณาจากความเป็นไปได้ทั้งภายในและภายนอกและข้อมูลคอนเทนเนอร์พื้นฐานที่จำเป็นต่อการสร้างการเชื่อมต่อคอนเทนเนอร์

วิธีการ:

• Internal Connection – การตั้งค่าการเชื่อมต่อภายในคอนเทนเนอร์
• External Connection – การเชื่อมต่อภายในเพื่อเข้าถึงคอนเทนเนอร์ภายนอก

Internal Connection

ในแต่ละคอนเทนเนอร์ของ Ruk-Com Cloud จะได้รับชื่อโดเมนภายในที่ไม่ซ้ำกันโดยอัตโนมัติและที่อยู่ IP ภายในทันทีหลังจากสร้างคอนเทนเนอร์ นอกจากนี้พารามิเตอร์เหล่านั้นยังสามารถใช้เพื่อเข้าถึงคอนเทนเนอร์ได้ ภายในขอบเขตของ cloud เดียวกัน (เช่น การสร้างการเชื่อมต่อระหว่างกันผ่านเครือข่ายภายในแพลตฟอร์ม)

1. ตัวเลือกแรกที่คุณจะต้องพิจารณาเมื่อต้องการตั้งค่าการเชื่อมต่อระหว่างคอนเทนเนอร์ คือฟังก์ชั่นการเชื่อมโยงแบบฝังตัว ซึ่งจะอนุญาตให้เชื่อมต่อคอนเทนเนอร์จาก layer ต่างๆภายใน environment เดียวกันเพื่อการย้ายข้อมูลอย่างปลอดภัย โดยข้อมูล variables จาก Docker image จะส่งไปยังผู้รับโดยไม่เผยแพร่ ports ใดๆออกไปภายนอก

ด้วยเหตุนี้ คุณเพียงเลือก layer ที่ต้องการและระบุ alias สำหรับการเชื่อมต่อ (ขณะที่ variables ที่เหมาะสมทั้งหมดจะมีคำนำหน้าระบุไว้):

หลังจากนั้นคุณสามารถอ้างอิงถึงส่วนของ Variables ของการตั้งค่าคอนเทนเนอร์และการปรับค่าต่างๆที่อยู่แยกกัน ตามความจำเป็น อย่างไรก็ตามการเปลี่ยนแปลงค่า variable ของ environment สำหรับคอนเทนเนอร์ที่เชื่อมโยงกับคอนเทนเนอร์อื่นอยู่แล้วและถูกนำไปใช้จะเกิดการอัปเดตโดยอัตโนมัติ

ในกรณีที่ต้องการสร้างการเชื่อมต่อภายในประเภทอื่นๆ (เช่น หากต้องการปรับเปลี่ยนด้วยตัวเองผ่าน configuration files) จำเป็นต้องทราบชื่อโดเมนหรือ IP ของคอนเทนเนอร์ที่แน่นอนและสามารถเข้าถึงได้ผ่านเครือข่ายภายในแพลตฟอร์ม

ข้อมูลที่เหมาะสมสามารถรับได้ 2 วิธีดังนี้:

• ผ่านการแจ้งเตือนทาง email ที่คุณได้รับหลังจากสร้าง environment โดยชื่อโดเมนภายในจะแสดงอยู่ในส่วนที่มีข้อมูลของผู้ดูแลคอนเทนเนอร์:

• ผ่าน Ruk-Com Cloud Dashboard ข้อมูลเดียวกันสามารถพบได้โดยวิธีต่อไปนี้:
  • คลิกปุ่ม Open in Browser ถัดจากคอนเทนเนอร์ โดยเลือก node ที่คุณต้องการเปิดในแท็บบราวเซอร์ใหม่ ดังนั้นคุณสามารถคัดลอกโดเมนได้อย่างง่ายดายจากแถบที่อยู่
  • Ip address ของ node สามารถดูได้จาก Node ID สำหรับคอนเทนเนอร์ที่ต้องการดังที่แสดงในภาพด้านล่าง

External Connection

เพื่อที่จะเข้าถึงคอนเทนเนอร์ของคุณจากแพลตฟอร์มภายนอก (เช่น จากอินเตอร์เน็ต) Ruk-Com Cloud เสนอวิธีการแก้ปัญหาดังนี้:

1. หากบริการหรือแอปพลิเคชันของคุณทำงานอยู่ในคอนเทนเนอร์ที่ฟัง port 80 จะถูกเปิดเผยอัตโนมัติไปยังเครือข่ายภายนอก (ผ่านชื่อโดเมนที่กำหนด) ผ่าน Ruk-Com Cloud Shared Load Balancer

หมายเหตุ: ในกรณีที่คอนเทนเนอร์ของคุณไม่มี IP ภายนอกแนบมาด้วย Ruk-Com Cloud จะทำการ redirect port โดยอัตโนมัติ ซึ่งหมายความว่าหากแอปพลิเคชันฟัง port ที่กำหนดเองระดับ TCP Ruk-Com Cloud ระบบจะพยายามตรวจหาโดยอัตโนมัติและส่งคำขอที้เข้ามาทั้งหมดไปยังหมายเลข port นี้ ด้วยเหตุนี้บริการหรือแอปพลิเคชันส่วนใหญ่จะพร้อมใช้งานบนอินเตอร์เน็ต ภายใต้โดเมนของ node ที่เกี่ยวข้องทันทีหลังจากสร้างเสร็จ

อย่างไรก็ตาม ในกรณีที่คุณต้องการป้องกันความเป็นไปได้ดังกล่าว คุณสามารถประกาศกฏที่เกี่ยวข้องได้ที่การตั้งค่า firewall ในคอนเทนเนอร์ของคุณ

2. สำหรับการปฏิบัติการที่ซับซ้อนมากขึ้น Ruk-Com Cloud จัดเตรียมฟังก์ชั่นปลายทางพิเศษ endpoints (ที่พร้อมใช้งานสำหรับส่วนที่มีชื่อเดียวกันของการตั้งค่าแต่ละ environment):

โดยอนุญาตให้เปิด private port ที่คุณต้องการบนคอนเทนเนอร์ผ่านการสุ่ม public port ที่ Ruk-Com Cloud Shared Load Balancer เพื่อให้สามารถเข้าถึงได้ผ่าน Access URL

3. ตัวเลือกสุดท้ายที่ให้อิสระสูงสุดคือการแนบที่อยู่ของ public IP เข้ากับคอนเทนเนอร์ (เช่น การรักษาความปลอดภัยกับการเชื่อมต่อแบบกำหนด SSL เองและการจำกัดจำนวนของการเชื่อมต่อพร้อมกัน ฯลฯ)

ด้วยวิธีดังกล่าว แอปพลิเคชันของคุณสามารถกำหนดค่าให้ฟัง port ใดก็ได้ที่คุณต้องการในลักษณะดังกล่าวเพื่อการเข้าถึงผ่านเครือข่ายภายนอก

หมายเหตุ: Public IP เป็นตัวเลือกเสริมที่ต้องชำระเงิน โดยคุณสามารถดูค่าใช้จ่ายได้เพียงวางเม้าส์ที่กล่องราคาส่วนขวาของ topology wizard หรือคลิกที่ Quotas & Pricing > Pricing > Options tab

ตอนนี้คุณสามารถใช้ประโยชน์จากตัวเลือกการเชื่อมต่อที่เหมาะสมที่สุด จากตัวเลือกต่างๆที่อธิบายไว้ข้างต้นในขณะที่ทำงานร่วมกับ Docker containers

หากคุณประสบปัญหาขณะตั้งค่าการเชื่อมต่อกับคอนเทนเนอร์ที่ Ruk-Com Cloud คุณสามารถขอความช่วยเหลือจากผู้เชี่ยวชาญทางเทคนิคได้ที่ Stackoverflow

The post Connect to Custom Container appeared first on คู่มือการใช้งาน Ruk-Com Cloud (PAAS).

• หมายเหตุ: คอนเทนเนอร์ที่ใช้ระบบปฏิบัติการ CentOS 8 ไม่รองรับบริการ NAT ซึ่งส่งผลให้มีข้อจำกัดดังต่อไปนี้:
  • กฏของ NAT ไม่สามารถเพิ่มหรือดำเนินการได้
  • ports auto-redirect ไม่ทำงาน
  • Let’s Encrypt ไม่สามารถติดตั้งเพิ่มได้

หากคุณต้องการใช้คอนเทนเนอร์ประเภทอื่น โปรดติดต่อเราเพื่อเจรจาเกี่ยวกับการสนับสนุนระบบปฏิบัติการที่เหมาะสม

The post Supported OS Distributions for Containers appeared first on คู่มือการใช้งาน Ruk-Com Cloud (PAAS).

Ports ใช้สำหรับข้อมูลทั่วไปเกี่ยวกับการจัดการพอร์ตคอนเทนเนอร์ที่ Ruk-Com Cloud PaaS

Ports ดังต่อไปนี้จะเปิดโดยค่าเริ่มต้น:

• 80, 8080, 8686 – proxies HTTP traffic ไปยัง HTTP (80 port)
• 4848, 8443, 4901-4910 – proxies SSL (HTTPS) traffic is proxied ไปยัง SSL
• 443 – proxies SSL traffic is proxied ไปยัง HTTP (80 port)
• 4949, 7979 – proxies SSL traffic ไปยัง HTTP
  
  

เคล็ดลับ: ดูตารางด้านล่างเพื่อใช้เป็นข้อมูลอ้างอิง

Port on SLB	Backend Port	Frontend SSL	Backend SSL
80, 8080, 8086	80	no	no
4848	4848	yes	yes
8443	8443	yes	yes
4901-4910	4901-4910	yes	yes
443	80	yes	no
4949	4949	yes	no
7979	7979	yes	no

 

Ports เพิ่มเติมสามารถเปิดได้โดยใช้:

• endpoints – แมปพอร์ตภายในคอนเทนเนอร์ไปยังภายนอกแบบสุ่ม ผ่าน Ruk-Com Cloud Shared LB
• Public IP – จัดเตรียมการเข้าถึงโดยตรงไปยังพอร์ตทั้งหมดของคอนเทนเนอร์

 

 

Ports Auto-Redirect

Ruk-Com Cloud PaaS จะเปลี่ยนเส้นทางที่ขอเข้ามาโดยอัตโนมัติ ไปยังแอปพลิเคชันโฮสต์ภายในคอนเทนเนอร์

ในระหว่างการสร้าง node แพลตฟอร์มจะตรวจจับพอร์ตที่รับฟังในระดับ TCP ทั่วไปที่ใช้เป็นมาตรฐานสำหรับบริการ (เช่น SSH, mail, database ฯลฯ) จะถูกกรองโดยอัตโนมัติ พอร์ตแรกในพอร์ตที่เหลืออยู่จะกลายเป็นการเข้าคอนเทนเนอร์ เพื่อ request ขาเข้าทั้งหมดและส่งออกไปยังพอร์ตนั้น

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

• 0 หรือ DISABLED หรือ FALSE – เพื่อปิดการใช้งาน disable auto-redirect
• ตัวเลขช่วง 1-65535 – เพื่อกำหนดพอร์ตคอนเทนเนอร์ ซึ่งจะรับ traffic ขาเข้า (ตำแหน่งที่จะเปลี่ยนเส้นทาง redirect)
• หากระบุค่าอื่นไว้ ฟังก์ชั่นการเปลี่ยนเส้นทาง auto-redirect จะทำงานได้ตามปกติ

อีกวิธีหนึ่งคุณสามารถระบุรายการพอร์ตด้วยเครื่องหมายจุลภาค “,” คั่นกลาง ผ่านตัวแปร JELASTIC_PRIORITY_PORTS แพลตฟอร์มจะตรวจสอบทีละรายการโดย redirect การกำหนดค่าที่ entry point ไปยังบริการที่ค้นพบว่าใช้งานอยู่ ซึ่งตัวเลือกนี้สามารถช่วยให้เวลาในการเริ่มต้นคอนเทนเนอร์เร็วขึ้นเมื่อเทียบกับการวิเคราะห์พอร์ตทั้งหมดในระหว่างขั้นตอนการ redirect

 

• เพิ่มเติม:
  • หากระบุพอร์ตที่แน่นอนผ่านตัวแปร JELASTIC_EXPOSE; JELASTIC_PRIORITY_PORTS จะถูกละเว้น
  • หากไม่พบบริการบน JELASTIC_PRIORITY_PORTS ค่าเริ่มต้น auto-redirect flow จะถูกเรียกใช้
  • เมื่อใช้งานกับ NodeJS แอปพลิเคชันเซิร์ฟเวอร์ สามารถใช้ตัวแปร REDIRECT_EXCLUDE_PORTS เพิ่มเติมเพื่อแยกพอร์ตจาก auto-redirect algorithm (เช่นพอร์ต 80 จะไม่เปลี่ยนเส้นทางไปยังพอร์ตเหล่านี้)

เพื่อให้สามารถเข้าถึง node ได้อย่างยืดหยุ่นมากขึ้น คุณสามารถกำหนดการตั้งค่า container firewall ของคุณเองได้

The post Ports appeared first on คู่มือการใช้งาน Ruk-Com Cloud (PAAS).

• Setting Wizard
• Embedded File Manager
• Log Files
• SSH Access

Container Layer Settings Wizard

Ruk-Com Cloud รวบรวมการตั้งค่า Docker layer แบบพิเศษเข้ากับ topology wizard เพื่อปรับเปลี่ยนการตั้งค่าคอนเทนเนอร์ที่จำเป็น โดยไม่จำเป็นต้องเข้าถึงผ่าน SSH ซึ่งจะช่วยให้คุณสามารถกำหนดค่าคอนเทนเนอร์ของคุณได้ง่ายและสะดวกที่สุด

ดังนั้นคุณต้องเริ่มจากการเข้าถึงเฟรมดังกล่าวข้างต้น ซึ่งมี 2 วิธีที่สามารถทำได้ดังนี้:

• Topology wizard – คลิกปุ่ม New Environment และเพิ่มคอนเทนเนอร์ที่ต้องการ หรือกดปุ่ม Change Environment Topology สำหรับ environment ที่สร้างไว้แล้ว
  

จากนั้นเลือกคอนเทนเนอร์ที่ต้องการปรับแต่งและเลือกการกำหนดค่าให้เหมาะสมตามการใช้งาน (สี่เหลี่ยมดานล่าง) ได้แก่ Variables, Volumes, Links, More เป็นต้น

เคล็ดลับ: Ruk-Com Cloud คอนเทนเนอร์สามารถกำหนดค่าล่วงหน้าได้ก่อนที่จะสร้าง data ที่จำเป็นจะถูกดึงโดยอัตโนมัติจากรายการ image เมื่อเข้าถึงการกำหนดค่า wizard

• Directly from the dashboard – วางเมาส์เหนือ environment layer แล้วคลิกที่ไอคอนรูปเฟืองเพื่อเลือกตัวเลือกการเข้าถึงจากลิสรายการ
  

หลังจากนั้นการตั้งค่า Docker layer จะปรากฏขึ้น:

ดังที่คุณเห็นการตั้งค่าจะประกอบด้วย 5 ส่วนและตัวเลือกการตั้งค่าถัดไป คุณสามารถเลือกใช้ตามคำแนะนำที่เหมาะสมด้านล่างสำหรับหัวข้อที่คุณสนใจ:

• Variables
• Links
• Volumes
• Ports
• Run Configuration

Configuration File Manager

การจัดการ configuration file ของ Ruk-Com Cloud ออกแบบมาเพื่อจัดการไฟล์ภายในคอนเทนเนอร์ของคุณ (รวมถึงไฟล์ที่พร้อมใช้งาน/หรือ export โดยฟังก์ชั่น Shared Storage Container) และสามารถเปิดแท็บที่เหมาะสมได้โดยคลิกที่ปุ่ม Config ที่อยู่ถัดจาก node (หรือ layer ทั้งหมด)

Application Servers: Config จะประกอบไปด้วย 4 ส่วนหลักๆคือ:

• Root (File Manager) – ช่วยในการเข้าถึง filesystem ภายในคอนเทนเนอร์ ซึ่งคุณสามารถใช้ข้อมูลที่ประกอบด้วย data และการตั้งค่า instance ภายใน configuration file ที่เกี่ยวข้อง
• Mount Points – รายการของโฟลเดอร์ที่จัดเก็บแบบ physical remote node แต่สามารถใช้กับคอนเทนเนอร์ปัจจุบันผ่านการติดตั้ง mounting directories ของข้อมูลที่ต้องการ
• Exports – รายการของโฟลเดอร์ที่ใช้ร่วมกันกับ node อื่น เช่น การ export ให้พร้อมใช้งานสำหรับ remote instances ในขณะที่จัดเก็บไว้ในเครื่อง
• Favorites – เพิ่มรายการโปรดของไฟล์และโฟลเดอร์ที่ใช้ทั่วไปเพื่อการเข้าถึงที่ง่ายและรวดเร็ว (คุณสามารถกำหนดรายการโปรดได้ด้วยตนเอง)

เคล็ดลับ: ในกรณีที่ environment layer ประกอบด้วยคอนเทนเนอร์ประเภทเดียวกันหลายตัว คุณสามารถสลับคอนเทนเนอร์เหล่านี้ได้โดยตรงผ่านการจัดการภายในคอนเทนเนอร์ โดยเลือกรายการที่ต้องการใน drop-down list ที่เกี่ยวข้องตรง Node ID

วิธีการจัดการไฟล์ดังกล่าวจะช่วยควบคุม file system ได้อย่างเต็มที่โดยไม่ต้องใช้เครื่องมืออื่นๆเพิ่มเติม อย่างไรก็ตามเมื่อคุณแก้ไขและเปลี่ยนแปลงแล้วเกิดบางอย่างเสียหายจะไม่สามารถเปลี่ยนกลับได้โดยอัตโนมัติ

Log Files

Log files เป็นอีกส่วนของ Ruk-Com Cloud Dashboard ที่สามารถช่วยในการจัดการโปรเจกต์ของคุณ โดยข้อมูลของวงจรคอนเทนเนอร์ทั้งหมดจะถูกรวบรวมไว้ ซึ่งอาจจะมีประโยชน์ในการแก้ไขปัญหหาหรือ debug แอปพลิเคชันหรือบริการของคุณ

การบันทึก log files ภายในคอนเทนเนอร์จะถูกสับเปลี่ยนอัตโนมัติ เมื่อไฟล์มีขนาดถึง 50 MB ไฟล์จะถูกบีบอัดและย้ายไปที่ rotated_logs directory หากคุณจำเป็นต้องดูไฟล์ดังกล่าว คุณต้องใส่ข้อมูลคอนเทนเนอร์ที่เหมาะสมผ่าน SSH และดาวน์โหลดไฟล์เพื่อตรวจสอบในเครื่อง logที่ถูกบีบอัดจะถูกเก็บไว้ 7 วัน หลังจากนั้นจะถูกลบออกโดยอัตโนมัติ โดยจะถือว่าเป็นข้อมูลที่เลิกใช้แล้ว

SSH Access to Container

หากคุณต้องการจัดก่านคอนเทนเนอร์ของคุณผ่าน terminal คุณสามารถเชื่อมต่อกับคอนเทนเนอร์ได้ผ่าน SSH (ไม่ว่าจะแนบIP/address หรือไม่ก็ตาม) เมื่อเชื่อมต่อแล้วคุณจะได้รับอิสระในการจัดการ instance โดยตรงจากเครื่องของคุณ

นอกจากนี้แพลตฟอร์มของเรายังมาพร้อมกับ Ruk-Com Cloud CLI ซึ่งจะช่วยในการจัดการและดำเนินการเกี่ยวกับวงจรการใช้งานแอปพลิเคชันของคุณโดยใช้ชุด scripts พิเศษ ด้วยเหตุนี้โครงสร้าง commands จะทำคล้ายกับ API โดยจัดระบบตามลำดับขั้น ดังนั้นคุณจึงคุ้นเคยกับการใช้งานและสารมารถทำงานร่วมกับลูกค้าได้อย่างง่ายดาย

The post Container Configuration appeared first on คู่มือการใช้งาน Ruk-Com Cloud (PAAS).

โซลูชันส่วนใหญ่ของ Docker (รวมถึง stacks ที่จัดการโดย Ruk-Com Cloud) ได้รับการพัฒนาผลิตภัณฑ์เป็นเวอร์ชันใหม่และการแก้ไขอย่างต่อเนื่อง ดังนั้นเราจึงแนะนำให้คุณอัปเดตเทมเพลตเป็นประจำตามเวอร์ชันล่าสุด

การดำเนินการดังกล่าว เรียกว่า “redeploy” เมื่อมีการจัดการบนแพลตฟอร์มจะมีข้อมูลจำเพาะดังต่อไปนี้:

• ข้อมูลผู้ใช้งานแบบกำหนดเองและไฟล์ที่ละเอียดอ่อนในระบบจะถูกเก็บรักษาไว้ในระหว่างการอัปเดต:
  • เนื้อหาของไดรฟ์ข้อมูล volumes (ค่าเริ่มต้นและแบบกำหนดเอง)
  • ลิสไฟล์ใน /etc/jelastic/redeploy.conf (การกำหนดค่าเฉพาะของสแต็ก Ruk-Com Cloud) เพื่อรับรองว่าคอนเทนเนอร์สามารถใช้งานได้
  • การกำหนดค่าที่เกี่ยวข้องกับ AutoFS และ NFS (/etc/autofs.jelastic, /etc/auto.master, /etc/exports)
  • การกำหนดค่า firewall (/etc/sysconfig/iptables-custom, /etc/sysconfig/iptables4-jelastic, /etc/sysconfig/iptables6-jelastic, /etc/iptables/rules.v4)
  • การเข้าถึงข้อมูล SSH (/root/.ssh/authorized_keys, /root/.ssh/authorized_keys2, /root/.ssh/id_rsa)
• การกำหนดค่าแบบกำหนดเองที่ระบุไว้ก่อนหน้านี้ทั้งหมดจะไม่ได้รับผลกระทบ เช่น run commands, links, variables และอื่นๆ
• หากใช้งานกับหลายๆ instances (ปรับขนาดแบบ horizontal) สามารถดำเนินการอัปเดตคอนเทนเนอร์ได้ทีละรายการ โดยไม่หยุดทำงาน (downtime)

ด้วยวิธีนี้คุณสามารถอัปเดต Docker-based container เป็นเวอร์ชันใหม่ได้ โดยจะไม่ส่งผลกระทบต่อแอปพลิเคชันภายในด้วย Ruk-Com Cloud PaaS การ redeploy คอนเทนเนอร์ใหม่สามารถทำได้ง่าย เพียงไม่กี่ขั้นตอน เช่นคลิกผ่าน dashboard UI หรือทำงานอัตโนมัติ ผ่าน API

หมายเหตุ:
การทำงานร่วมกับ MySQL, MariaDB, หรือ Percona databases จะไม่รองรับการ downgrade (การ redeploy เป็นเวอร์ชันที่เก่ากว่า) แต่หากจำเป็นต้องดำเนินการ เราขอแนะนำให้สำรองข้อมูลและกู้ database คืนหลังจากการ redeploy (หรือในคอนเทนเนอร์ที่แยกออกจากกันทั้งหมด)

Update Container via Dashboard

วิธีที่ใช้งานง่ายที่สุดสำหรับการติดตั้งแท็กเทมเพลตใหม่ (redeploy) คือการใช้ Ruk-Com Cloud Dashboard ตามคำแนะนำและขั้นตอนที่จำเป็นดังต่อไปนี้:

1. การปรับการใช้งานใหม่สามารถเข้าถึงได้ 2 วิธีที่แตกต่างกัน:

• เลือกปุ่ม Redeploy Container(s) จาก node/layer ที่ต้องการ (สำหรับการอัปเดตคอนเทนเนอร์ทั้งหมดในครั้งเดียว)

• เลือกปุ่ม Changing Environment Topology เพื่อปรับเปลี่ยน environment เดิมที่มีอยู่

• คลิกไอคอนดินสอเพื่อเปลี่ยน Tag version สำหรับคอนเทนเนอร์ของคุณ

 

นอกจากนี้คุณสามารถปรับเปลี่ยนตัวเลือกเพิ่มเติมได้:

• เก็บข้อมูล volumes – หากเปิดใช้งานฐานข้อมูลใน volumes จะได้รับการป้องกันจากการลบและจะยังคงพร้อมใช้งานหลังจาก redeploy
• สำหรับคอนเทนเนอร์แบบ horizontal คุณสามารถเลือกได้ 2 ตัวเลือก:
  • Simultaneous deployment – redeploy nodes ทั้งหมดในครั้งเดียว ซึ่งค่อนข้างเร็วกว่า แต่จะทำให้แอปพลิเคชันของคุณหยุดทำงานในระยะเวลาสั้นๆ (มี downtime)
  • Sequential deployment with delay – redeploy instances ใหม่ทีละรายการ ซึ่งจะค่อนข้างช้า แต่ node ยังคงทำงานอยู่เพื่อรันคำขอที่เข้ามาอยู่เสมอ (ไม่มี downtime)

 

หลังจากกำหนดค่าทั้งหมดเรียบร้อยแล้วให้คลิกปุ่ม Redeploy และกดปุ่มยืนยัน Yes

3. หลังจากการอัปเดตเสร็จสิ้นคุณจะเห็นการแจ้งเตือนที่มุมบนขวาของ dashboard

คลิกปุ่ม Show Logs เพื่อดูข้อมูลเกี่ยวกับคอนเทนเนอร์ที่อัปเดต Node ID, name:tag และ Duration

ในตอนนี้คุณรู้วิธี redeploy คอนเทนเนอร์ผ่าน Ruk-Com Cloud Dashboard แล้ว บทความต่อจากนี้คือวิธีการอัปเดตคอนเทนเนอร์ผ่าน Ruk-Com Cloud API/CS/CLI

Update Container via Ruk-Com Cloud API/CS/CLI

กระบวนการอัปเดตสามารถดำเนินการได้อัตโนมัติโดยใช้ Ruk-Com Cloud API, Cloud Scripting และ CLI (command-line interface)

เคล็ดลับ: ตัวอย่างข้อมูลโดยละเอียดเกี่ยวกับการ redeploy คอนเทนเนอร์ผ่าน CLI

การ redeploy คอนเทนเนอร์ใหม่จะดำเนินการกับวิธี environment.Control.RedeployContainers ซึ่งสามารถจัดการด้วยพารามิเตอร์ต่อไปนี้:

• envName – ชื่อของ environment ที่คอนเทนเนอร์ควรจะ redeploy
• session – ระบุ session ของผู้ใช้งาน (หรือ token) เพื่อใช้สำหรับการพิสูจน์ตัวตน
• nodeGroup – ระบุ environment layer ที่ต้องการอัปเดต (ไม่บังคับ)
• nodeId – ระบุหมายเลขประจำตัวของคอนเทนเนอร์เฉพาะที่จะ redeploy (ไม่บังคับ)

คุณต้องระบุพารามิเตอร์ nodeGroup หรือ nodeId เพื่อกำหนดเป้าหมายของการดำเนินการ การละเว้น nodeGroup หากไม่ได้ระบุไว้อาจล้มเหลว

• tag – เวอร์ชันของ image ที่จะติดตั้ง (deploy)
• useExistingVolumes – ตั้งค่าเป็น true เพื่อเก็บข้อมูลไว้ใน volumes ที่อยู่ภายในคอนเทนเนอร์ที่อัปเดตแล้ว (ไม่บังคับ)
• login และ password – ข้อมูลรับรองการเข้าถึง image จาก private registry (ไม่บังคับ)
• skipReinstall – กำหนดว่าควรแตก image บนระบบไฟล์ที่มีอยู่ (true) หรือติดตั้งกับอินสแตนซ์ใหม่ (ค่าเริ่มต้น false) (ไม่บังคับ)

คุณสามารถใช้โครงสร้างต่อไปนี้เพื่อกำหนดการอัปเดตคอนเทนเนอร์ภายใน automation scripts:

1. การ redeploy layer ของคอนเทนเนอร์ทั้งหมด

ดังนี้:

• {nodeGroup} – environment layer (หรือ node group) ที่ควรอัปเดตทั้งหมด
• {myImage} – ชื่อของ image ที่ต้องการจะ deploy
• {newTag} – เวอร์ชันของ Image ที่ต้องการ

2. อัปเดตคอนเทนเนอร์โดยเฉพาะ

ในที่นี้ควรแทนค่า {nodeId} ด้วยเลข ID ของ node ที่ต้องการ (ส่วนของตัวอื่นๆเหมือนกับตัวอย่างด้านบน)

Saving Custom Data during Container Redeploy

ในแต่ละคอนเทนเนอร์ที่จัดการโดย Ruk-Com Cloud จะมีไฟล์พิเศษชื่อว่า redeploy.conf ซึ่งจะจัดเก็บลิสที่จำเป็นของคอนเทนเนอร์ โดยการตั้งค่าเหล่านี้จะถูกเก็บรักษาไว้ในแพลตฟอร์มโดยอัตโนมัติในระหว่างการ redeploy คอนเทนเนอร์ ด้วยเหตุนี้ไฟล์ทั่วไปบางไฟล์จะถูกจัดเตรียมไว้ใน stacks ทั้งหมด:

• /etc/jelastic/redeploy.conf – การกำหนดค่า redeploy ในปัจจุบัน (เพื่อจัดเก็บรายการที่จำเป็นสำหรับการบันทึกไฟล์และที่เก็บรวบรวมไฟล์ต่างๆ ระหว่างการติดตั้งคอนเทนเนอร์ใหม่แต่ละครั้ง)
• ${home}/.bash_profile – ประกอบด้วยการตั้งค่า SSH shell เริ่มต้น (เช่นข้อความแนะนำ shell,การ config ไฟล์ที่จำเป็นจะต้องดึงข้อมูล ฯลฯ)
• /etc/sysconfig/iptables – จัดเก็บกฏของ firewall เริ่มต้น
• /etc/sysconfig/iptables-custom – ประกอบด้วยกฏของ firewall ที่กำหนดเอง
• /var/lib/jelastic/keys – จัดเก็บ SSH private keys ที่อัปโหลดซึ่งจำเป็นต่อการเข้าถึงคอนเทนเนอร์ผ่าน SSH และสำหรับการโต้ตอบกับคอนเทนเนอร์อื่น

นอกจากนี้คุณสามารถคลิกที่นี่เพื่อดูไฟล์ stack ที่แตกต่างกันโดยเฉพาะของ redeploy.conf สำหรับ node แต่ละประเภท

การเก็บรักษาลิสเริ่มต้นของการกำหนดค่าไว้ สามารถเพิ่มเติมร่วมกับไฟล์และโฟลเดอร์ที่กำหนดเองของคุณโดยเปิดไฟล์ redeploy.conf และเพิ่มชื่อ path ไปยังรายการที่คุณต้องการ (แต่ละรายการควรระบุแยกบรรทัดกัน)

Creating File Backup Copy Upon Image Redeployment

Ruk-Com Cloud PaaS จัดเตรียมวิธีที่ง่ายและสะดวกในการสำรองข้อมูลสำหรับ configuration files ในระหว่างที่อัปเดตคอนเทนเนอร์ กล่าวคือ นอกเหนือจากการแทนที่การกำหนดค่าที่ระบุเวอร์ชันจาก tag ใหม่แล้วสำเนาของไฟล์ก่อน redeploy จะถูกเก็บรักษาไว้

ในส่วนของการสำรองข้อมูล คุณจะต้องระบุ path ไปยังไฟล์ที่จำเป็น redeploy.conf จากนั้นเพิ่มคำนำหน้าไฟล์ “backup:” เพื่อบันทึก:

หมายเหตุ: การดำเนินการนี้พร้อมใช้งานสำหรับไฟล์เท่านั้น (ไม่ใช่ที่จัดเก็บไฟล์ directories)

หลังจาก redeploy การกำหนดค่าจากคอนเทนเนอร์เก่าสามารถจำแนกได้โดยค้นหาจากส่วนขยาย “.backup” ซึ่งสามารถใช้สำหรับการย้อนกลับได้ทันที หากไม่สามารถเข้ากันได้กับการกำหนดค่าใหม่หรือการวิเคราะห์การเปลี่ยนแปลง

ยกตัวอย่างเช่น การจัดการ PHP application servers ของ Ruk-Com Cloud ทั้งหมดเพื่อสร้างการสำรองข้อมูล /etc/php.ini config.

หลังจากอัปเดตคอนเทนเนอร์คุณจะเห็นไฟล์ php.ini เวอร์ชันใหม่และเวอร์ชันก่อนหน้า

หมายเหตุ: การสำรองไฟล์ {file_name} ใหม่จะแทนที่ข้อมูลสำรองก่อนหน้าโดยอัตโนมัติ (ไฟล์ชื่อเดิมที่มีอยู่) ในระหว่างการ redeploy

ด้วยวิธีนี้คุณสามารถเปลี่ยนไปใช้การตั้งค่าก่อนหน้านี้ได้อย่างง่ายดายโดยแทนที่ไฟล์ php.ini ด้วยการสำรองข้อมูล (เช่นการเปลี่ยนชื่อไฟล์หรือการคัดลอกเนื้อหา) ตอนนี้คุณก็ได้รู้วิธีจัดการ templates versions (Docker tags) ของคอนเทนเนอร์ภายใน Ruk-Com Cloud PaaS แล้วติดตั้ง

The post Container Redeploy appeared first on คู่มือการใช้งาน Ruk-Com Cloud (PAAS).

Ruk-Com Cloud PaaS รองรับ Docker Engine Community Edition ซึ่งสามารถทำงานร่วมกันได้อย่างสมบูรณ์แบบเหมือนกับระบบ Docker เดิม การทำงานร่วมกันดังกล่าวทำให้ Ruk-Com Cloud ใช้เครื่องมือหลักของเทคโนโลยี Docker container ได้แก่:

• Docker Engine – ขั้นตอนการประมวลผล Dockerfile แสดงหรือเรียกใช้คอนเทนเนอร์ image ที่สร้างไว้แล้ว
• Docker Registry – จัดเก็บและจัดเตรียมการเข้าถึง image แบบ private/public จำนวนมากเพื่อติดตั้งภายใน Docker Engine
• Docker Compose – ช่วยในการรวบรวมแอปพลิเคชันที่มีหลายองค์ประกอบและกำหนดค่าทั้งหมดไว้ในไฟล์เดียว
• Docker Swarm – Docker node ที่เป็นอิสระหลาย nodes เชื่อมต่อกันเป็นคลัสเตอร์

1. Docker Engine CE เป็นโปรแกรมสำเร็จรูปที่มีจำหน่ายผ่าน Ruk-Com Cloud Marketplace สามารถค้นหาแพ็คเกจได้ในหมวด Dev & Admin Tools:

2. เมื่อติดตั้งจาก Marketplace คุณสามารถเลือกเวอร์ชั่นของ Docker ที่ต้องการได้จากลิสตัวเลือกและสามารถเลือกการ deploy ต่างๆเพื่อทำให้การดำเนินการทั่วไปเป็นไปโดยอัตโนมัติ:

• สร้าง engine แบบ standlone – ตั้งค่า node ที่ว่างโดยมี Docker daemon อยู่ภายใน หรือคุณสามารถติดตั้ง Portainer UI เพิ่มเติมซึ่งเป็นเครื่องมือการจัดการบนเว็บได้
• เชื่อมต่อกับ swarm cluster ที่มีอยู่ – การรวม Docker Engine ใหม่เข้ากับ Docker Swarm ที่มีอยู่โดยอัตโนมัติ (เลือกคลัสเตอร์ที่เหมาะสมโดยใช้ token และ Host IP ร่วมกัน)
• ติดตั้งคอนเทนเนอร์จาก compose.yml – การ deploy แอปพลิเคชันอัตโนมัติจากที่เก็บแบบกำหนดเอง

คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับการติดตั้งและการจัดการ Docker Engine CE ผ่านบทความที่เกี่ยวข้องในบล็อกตามลิงก์ที่แนบไว้

The post Docker Engine Deployment appeared first on คู่มือการใช้งาน Ruk-Com Cloud (PAAS).

เคล็ดลับ: Ruk-Com Cloud จัดเตรียมซอร์ฟแวร์สแต็กที่ได้รับความนิยมสูงและเทมเพลตที่พร้อมใช้งาน สามารถอัปเดตเวอร์ชันได้เป็นประจำ (คอนเทนเนอร์ที่ผ่านการรับรอง)

ภายในคู่มือจะมีวิธีการใช้งานเบื้องต้นสำหรับการกำหนด Docker คอนเทนเนอร์ – วิธีสร้างและวิธีจัดการแอปพลิเคชันและการให้บริการทุกประเภทที่มี่อยู่ใน Docker Hub หรือ registry ส่วนตัวที่คุณกำหนดเอง

การกำหนดคอนเทนเนอร์เองจาก Docker Hub

1. เปิด environment topology wizard โดยคลิกปุ่ม New Environment ที่มุมบนด้านซ้ายของแดชบอร์ด

ในแถบด้านซ้ายของ Docker wizard คุณจะเห็นบล็อกหลายอันที่มีชื่อเลเยอร์แตกต่างงกัน โดยแต่ละบล็อกสามารถสร้างคอนเทนเนอร์แบบกำหนดเองตาม image Docker ที่เลือกใช้ในส่วนเหล่านี้เพื่อแบ่งและจัดโครงสร้าง topology ตามการใช้งานของคุณ

คุณสามารถเลือกเลเยอร์ที่ต้องการและดำเนินการต่อโดยคลิกที่ Select Image เพื่อเพิ่ม Docker images เองได้

2. เมื่อเปิด Select Container จะมีแท็บต่างๆให้เลือกมากมาย

• Quick Start – ซอร์ฟแวร์ที่ได้รับความนิยม/เทมเพลตที่ได้รับคำแนะนำ สำหรับเลเยอร์ปัจจุบัน (แท็บนี้อาจไม่มี ขึ้นอยู่กับการตั้งค่าจากผู้ให้บริการโฮสติ้ง)
• Search – ช่วยในการค้นหาเทมเพลตที่ต้องการจาก Docker Hub ส่วนกลาง
• Custom – สามารถเพิ่มเทมเพลตของคุณเองจากรีจิสเตอร์ส่วนตัวหรือรีจิสเตอร์ที่กำหนดเอง
• Favorite – สามารถจัดเก็บ image ที่คาดว่าจะใช้ในอนาคตเพื่อการเข้าถึงได้อย่างรวดเร็ว

ดังตัวอย่างข้างต้น เช่นการค้นหา Docker Hub registry ไปที่แถบค้นหา พิมพ์ชื่อเต็ม/บางส่วนของชื่อที่ต้องการลงในช่องป้อนข้อมูล อย่างเช่น dockersample/static-site แล้วกด Enter จะแสดงรายการของ dockersample ทั้งหมด จากนั้นให้คลิกที่ dockersample/static-site เพื่อเพิ่มเข้าไปในเลเยอร์แอปพลิเคชันเซิร์ฟเวอร์ (จะมีเครื่องหมายถูกและเป็นไฮไลต์) อีกทั้งยังสามารถเลือกแท็กที่จำเป็นได้จาก drop-down ด้านบน

คุณสามารถเลือกเฉพาะ Docker image เดียวหรืออินสแตนซ์หลายตัวในเทมเพลตเดียวกัน (ต่อ 1 เลเยอร์) โดยวิธีนี้คุณสามารถเพิ่ม image อื่นๆในเลเยอร์ต่างๆโดยใช้บล็อกที่เหลือได้ตามต้องการ

3. เมื่อคุณกลับมาที่ wizard พร้อมกับคอนเทนเนอร์ที่กำหนดเองทั้งหมดแล้ว คุณสามารถเริ่มกำหนดค่าและจัดการได้เช่นเดียวกับ node ทั่วไป:

4. เพียงเท่านี้ ระบบจะสร้าง environment ตามคอนเทนเนอร์ที่คุณกำหนดภายในไม่กี่นาทีและจะแสดงอยู่บนแดชบอร์ดเมื่อสร้างเสร็จ

คุณสามารถคลิก open browser เพื่อเปิดในเบราว์เซอร์แต่ละคอนเทนเนอร์ด้วยปุ่มที่เกี่ยวข้องถัดจากนั้นหรือ environment ทั้งหมดที่แสดงผ่านโดเมนที่กำหนด (ด้านล่างชื่อ environment) ในกรณีหลังนี้แอปพลิเคชันเซิร์ฟเวอร์หรือเทมเพลตของ layer balancer จะเปิดขึ้น

หมายเหตุ: คอนเทนเนอร์ที่กำหนดเองบางส่วนอาจจะไม่มีหน้าเว็บ ดังนั้นคุณอาจได้รับข้อความ 502 application down เมื่อเข้าถึง node ดังกล่าวผ่านเบราว์เซอร์ อย่างไรก็ตาม image ไม่ได้รับความเสียหาย แต่หากคุณต้องการตรวจสอบให้แน่ใจว่าบริการนี้ใช้งานได้ สามารถเช็กที่กระบวนการทำงานภายในคอนเทนเนอร์โดยเชื่อมต่อกับ SSH ส่วนในกรณีที่แอปพลิเคชันถูกทำไปใช้กับคอนเทนเนอร์ที่ไม่มี public IP ที่ port 80/backend คุณจะเห็น 502 error – บริการหยุดทำงานโดยเฉพาะในขณะที่พยายามจะเปิดใช้งาน ในกรณีนี้ต้องตรวจสอบให้แน่ใจว่าคอนเทนเนอร์ของคุณมีบริการ HTTP ที่ทำงานอยู่สำหรับจัดการคำขอที่เข้ามาผ่านพอร์ตที่กล่าวถึงข้างต้น

ตัวอย่างแอปพลิเคชัน Docker เมื่อกด open browser

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

คอนเทนเนอร์จาก Custom/Private Registry

นอกเหนือจากเทมเพลตสาธารณะที่สามารถใช้งานได้ใน Docker Hub registry Ruk-Com Cloud ยังช่วยให้คุณสามารถ deploy image ส่วนตัวจากรีจิสตรีที่กำหนดได้เอง โดยแพลตฟอร์มจะจดจำและจัดเก็บไว้แยกส่วนเฉพาะ) ทำให้คุณสามารถใช้งานได้ในลักษณะเดียวกับ public image ในกรณีของที่จัดเก็บจะถูกป้องกันโดยคุณจะต้องระบุข้อมูลอ้างอิงที่เหมาะสมเพื่อการเข้าถึง (เพียงครั้งเดียวในระหว่างการเพิ่ม) ในขณะเดียวกันการตรวจสอบสิทธิ์ที่ตามมาทั้งหมดสำหรับการปรับขนาดคอนเทนเนอร์หรือการติดตั้งใหม่จะถูกดำเนินการโดยอัตโนมัติ

การเพิ่ม image ดังกล่าวสามารถทำได้ผ่าน Docker topology wizard

1. เริ่มต้นด้วยการกดปุ่ม New Environment จากนั้นคลิก select image แล้วเลือกแท็บ Custom

2. คลิก Add New Image เพื่อใส่ชื่อของรีจิสตรีที่จัดเก็บไว้ลงในช่อง ด้วยเหตุนี้ image จาก Docker Hub จะสามารถระบุได้โดยไม่ต้องตั้งค่าโฮสต์รีจิสทรีที่จุดเริ่มต้นของชื่อ image

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

3. ในส่วนของการจัดเก็บแบบส่วนตัว คุณจะต้องเพิ่มข้อมูลที่เหมาะสมเพื่อระบุตัวตนผ่าน Username และ Password จากนั้นคลิก Add เพื่อดำเนินการต่อ

หากคุณไม่ต้องการใช้เทมเพลตอีกต่อไปสามารถคลิกที่ไอคอนถังขยะ (bin) ที่มุมบนขวาเพื่อลบออก ในทำนองเดียวกันหากคุณต้องการรวม image ให้อยู่ในลิส คลิกที่ไอคอนรูปดาว (star) เพื่อการใช้งานในภายหลัง

4. ในกรณีที่คุณต้องการอัปเดตข้อมูลรับรองการเข้าถึงผ่านคอนเทนเนอร์ที่กำหนดเอง โดยวางเมาส์เหนือเลเยอร์ที่เหมาะสมในแดชบอร์ด คลิกไอคอนเฟืองเพื่อขยายรายการ จากนั้นคลิกที่ตัวเลือก Repo Credentials

5. เมื่อคลิก Repo Credentials จัดเก็บคอนเทนเนอร์จะมีข้อมูลส่วนตัวโดยคุณสามารถแก้ไขใหม่โดยเปลี่ยนชื่อ Login และ Password สำหรับ image ของคุณ

ทั้งหมดนี้คือการเพิ่มคอนเทนเนอร์แบบกำหนดเองจากที่เก็บของคุณ ไม่ใช่ค่าเริ่มต้นของ Ruk-Com Cloud PaaS

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

The post Custom Containers Deployment appeared first on คู่มือการใช้งาน Ruk-Com Cloud (PAAS).