คำสั่ง Docker เบื้องต้นสำหรับ Java Developer

การนำ Docker มาใช้ในการพัฒนา software นั้นถือว่าเป็นสิ่งที่น่าสนใจมาก ๆ บางคนอาจจะบอกว่า น่าจะเป็นความรู้พื้นฐานของนักพัฒนาเลยนะ แต่ว่าการศึกษาสิ่งใหม่ ๆ ก็ไม่ใช่เรื่องที่ง่ายเลย ดังนั้นจึงสรุปขั้นตอนการใช้งาน Docker เป็น comand line นะ พร้อมยกตัวอย่างการใช้งานสำหรับการพัฒนาระบบด้วยภาษา Java

แนะนำการใช้งาน Docker แบบพื้นฐาน

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

1. การจัดการ image

Image คือต้นฉบับสำหรับการสร้าง container ต่าง ๆ โดยที่เราสามารถทำการจัดการได้ดังนี้ เลือกคำสั่งที่ใช้บ่อย ๆ

• สร้าง image ใหม่ขึ้นมา กำหนดขั้นตอนการสร้างจาก Dockerfile
• ทำการลบ image
• ทำการดึง หรือ pull image มาจาก repository เช่น Docker Hub มายังเครื่องเราได้
• ทำการ push image ไปยัง repository

เริ่มต้นจากการเลือก image จาก Docker Hub หรือจาก Official ของสิ่งที่เราต้องการ ยกตัวอย่างเช่น Java ก็มีให้เลือกทั้ง OpenJDK และ Oracle Java อีกทั้งยังมีจาก community อีกนะ เลือกได้ตามรสนิยมกันไปเลย ทั้ง OS เช่น Ubuntu, Alpine เป็นต้น โดยเราจะเรียกว่า Base Image นั่นเอง แสดงดังรูป เมื่อได้ image ที่ต้องการแล้ว ก็นำมาใช้ได้เลย สามารถทำการ download image ลงมาด้วยคำสั่ง [code] $docker image pull <ชื่อ image>:<ชื่อ tag> [/code] ยกตัวอย่างเช่นการใช้งาน image openjdk ซึ่งมีให้เลือกมากมายทั้ง OS, JDK และ JRE เราจะใช้งาน openjdk ด้วย tag 9-jdk ดังนี้ [code] $docker image pull openjdk:9-jdk [/code] จากนั้นทำการดูว่า image ถูก download มายังเครื่องของเราหรือไม่ ด้วยคำสั่ง [code] $docker image ls [/code] ถ้าต้องการลบ image ให้ใช้คำสั่ง [code] $docker image rm <ชื่อ image> [/code] หรือถ้าต้องการลบ image ที่ไม่ถูกใช้งานเลย สามารถใช้คำสั่งใหม่คือ prune ดังนี้ [code] $docker image prune [/code]

นี่แค่เริ่มต้นคำสั่งจัดการ image เบื้องต้นเท่านั้น แต่เพียงพอสำหรับผู้เริ่มต้น

เมื่อได้ image หรือ base image ที่ต้องการแล้ว

ถ้าเราไม่พอใจ สามารถทำการแก้ไขและสร้าง image ใหม่ขึ้นมา เพื่อให้เหมาะสมกับระบบที่เราต้องการได้ สามารถกำหนดขั้นตอนการสร้าง image ผ่านไฟล์ Dockerfile ตัวอย่างง่าย ๆ ต้องการสร้าง image สำหรับการ compile และ run โปรแกรมที่พัฒนาด้วยภาษา Java คือ javac และ java มีขั้นตอนดังนี้

• เลือก Base image ซึ่งจะใช้ openjdk:9-jdk
• ทำการสร้าง working directory สำหรับจัดเก็บ source code
• กำหนด endpoint ให้ทำการ run bash shell ขึ้นมา

[gist id="07d5005207469bbe9c7d8da7ca5dd712" file="HelloDockerfile"] สร้าง image จาก Dockerfile ด้วยคำสั่ง [code] $docker image build -t <ชื่อ image>:<ชื่อ tag> . [/code] จากตัวอย่างถ้าต้องการสร้าง image ชื่อว่า hello_java ทำได้ดังนี้ [code] $docker image build -t hello_java . [/code] ส่วนการใช้งานต้องสร้าง container ขึ้นมาจาก image นี้ต่อไป ยกตัวอย่างเช่น [code] $docker container run --name java_compile -v $(pwd)/src:/my_project —rm hello_java javac Hello.java $docker container run --name java_run -v $(pwd)/src:/my_project —rm hello_java java Hello [/code]

ชีวิตน่าจะดีขึ้น ลองคิดดูสิว่า ถ้าเราต้องการ run java มากกว่า 1 version เราจะต้องทำอย่างไร ?

ตัวอย่างที่ซับซ้อนขึ้น ต้องการสร้าง image สำหรับระบบงานที่พัฒนาด้วยภาษา Java และต้องทำการ compile และ build ด้วย Apache Maven ดังนั้นเราต้องกำหนดขั้นตอนการสร้าง image ของเราดังนี้

• เลือก Base image ซึ่งจะใช้ openjdk:9-jdk
• ทำการติดตั้ง package ต่าง ๆ ที่จำเป็นนั่นคือ Apache Maven และ Vim เอาไว้แก้ไข code
• ทำการสร้าง working directory สำหรับจัดเก็บ source code
• กำหนด endpoint ให้ทำการ run bash shell ขึ้นมา

สามารถเขียนใน Dockerfile ได้ดังนี้ [gist id="07d5005207469bbe9c7d8da7ca5dd712" file="Dockerfile"] ทำการสร้าง image ชื่อว่า my_image ใหม่จาก Dockerfile ด้วยคำสั่ง [code] $docker image build -t my_image . [/code] โดยการสร้าง image จะใช้เวลานานนิดหน่อย ถ้าไม่ใสชื่อ tag เข้าไปจะมีค่า default เป็น latest นะ เพียงเท่านี้เราก็ได้ image ใหม่มาใช้งานกันแล้ว ในแต่ละบรรทัดของ Dockerfile นั่นหมายถึงจำนวน layer หรือชั้นของ image เราด้วย สามารถดูได้ว่าแต่ละ image มี layer อะไรบ้างด้วยคำสั่ง [code] $docker image history <ชื่อ image>:<ชื่อ tag> [/code] เมื่อเราได้ image ที่ต้องการแล้ว สามารถนำ image นี้ไปเก็บยัง repository ของ Docker ได้ ไม่ว่าจะเป็น Docker hub หรือ registry ของเราเอง ด้วยคำสั่ง [code] $docker image push <ชื่อ image>:<ชื่อ tag> [/code] มาถึงตรงนี้น่าจะพอทำให้เข้าใจเกี่ยวกับการจัดการ image ขั้นพื้นฐานบ้างแล้ว แน่นอนว่ายังมีอีกเยอะนะ แต่อยากขอแนะนำเพิ่มเติมเพื่อให้ศึกษาต่อคือ

• การเขียน docker file ที่ดี
• Multi-stage build

2. การจัดการ container

หลังจากที่ได้ image ที่ต้องการแล้ว สิ่งต่อมาที่จะต้องทำคือ การสร้าง container จาก image เหล่านั้น เทียบง่าย ๆ คือ การสร้าง instance/object จาก class ใน OOP นั่นเอง โดยทาง docker ได้เตรียม command line สำหรับการจัดการ container มาให้เพียบ แต่เรามาใช้งานคำสั่งที่ใช้บ่อย ๆ กัน เริ่มด้วยการสร้าง container จาก image [code] $docker container run<options> <ชื่อ image> <command> <arguments> [/code] จะเห็นได้ว่ามีให้ใส่ option ซึ่งมีเยอะมาก ๆ ดังนั้นมาดูตัวอย่างกัน ใช้ image จากข้างต้น

• สร้าง container ชื่อ demo01
• สร้างจาก image ชื่อว่า my_image
• map path จากเครื่องของเราหรือเรียกว่า host ไปยัง container
• Run container แบบ foreground mode (แสดงว่ายังมี mode อื่นอีกเช่น interactive และ background เป็นต้น)
• ลบ container ทิ้งทันทีหลังจากทำงานเสร็จสิ้น
• Run คำสั่งของ Apache Maven เพื่อ compile และ build ระบบงาน

สร้าง container ด้วยคำสั่ง [code] $docker container run --name demo01 -v $(pwd)/src:/my_project --rm my_image mvn clean package [/code] เพียงเท่านี้ก็สร้าง container ได้แล้ว และทำงานตาม command ของ Apache Maven ที่ต้องการ run มันง่ายและสะดวกมาก ๆ สำหรับนักพัฒนา ลองคิดดูว่า ถ้าทุกคนในทีมพัฒนาใช้งาน image เดียวกัน ถ้าทุกคนในทีมพัฒนาทำการสร้าง container เหมือนกัน นั่นคือทุกคนมีขั้นตอนการทำงานเหมือนกัน ที่สำคัญถ้า image นี้เหมือนกับสิ่งที่จะ deploy บน production server ก็น่าจะลดปัญหาต่าง ๆ ได้มากมาย จริงไหม ? ถ้าต้องการดูว่ามี container อะไรบ้างก็ใช้คำสั่ง ตัวอย่างดู container ทั้งหมด ทุกสถานะ [code] $docker container ls -a [/code] ยังมีคำสั่งอื่น ๆ ที่ใช้จัดการ container ทั้ง stop/start/restart/rm [code] $docker container stop <ชื่อ container> $docker container start <ชื่อ container> $docker container restart <ชื่อ container> $docker container rm <ชื่อ container> [/code] ถ้าต้องการลบ container ที่ไม่ทำงานสามารถใช้คำสั่ง prune ได้ [code] $docker container prune [/code] ถ้าต้องการลบ container ทั้งหมด ทุกสถานะ สามารถใช้คำสั่งนี้ได้เลย ใช้บ่อย [code] $docker container stop $(docker container ls -a -q) $docker container rm $(docker container ls -a -q) [/code] ยังไม่พอนะ ยังมีชุดคำสั่งสำหรับดู stat/log การทำงานของแต่ละ container ได้อีกด้วย [code] $docker container stats <ชื่อ container> $docker container top <ชื่อ container> $docker container logs <ชื่อ container> [/code] เพียงเท่านี้ก็น่าจะเพียงพอสำหรับการเริ่มต้นจัดการ container นะ

3. การกำหนดจำนวน resource ต่าง ๆ ทั้ง CPU และ Memory ให้ container

[code] $docker container update<options> container [/code] สำหรับชาว Java นั้นเรื่องนี้สำคัญมาก ๆ เนื่องจากถ้ากำหนดไม่ดี และไม่เข้าใจการทำงานของ JVM แล้ว ก็อาจเกิดข้อผิดพลาดได้ ยกตัวอย่างเช่นการใช้ resource เกินจำนวนที่กำหนด สามารถดูปัญหาและการแก้ไขได้จาก JVM is Docker-aware

คำสั่งสุดท้ายคือ การลบข้อมูลที่ไม่ใช้งานทิ้งไป

ลบทั้ง image, container, volume และ network รวมไปถึง layer ของจากการสร้าง image อีกด้วย ซึ่งทำให้เราได้พื้นที่ disk กลับคืนมาอย่างมากมาย [code] $docker system prune<options> [/code] แต่คำสั่งนี้ไม่ลบพวก container volume นะ ถ้าอยากจะลบต้องเพิ่ม option -volume เข้าไปด้วย

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

ยกตัวอย่างเรื่องที่ต้องศึกษาต่อเช่น

• Port
• Volume
• Network
• Linking
• Docker-compose

ถามว่าชุดคำสั่งเยอะไหม ? ตอบเลยว่ามาก ถามว่าต้องจำหมดไหม ? ตอบเลยว่าไม่ ดังนั้นสิ่งที่สำคัญสุด ๆ ความเข้าใจ และ keyword ที่ต้องการ

ขอให้สนุกกับการ coding ครับ