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

นักเทียบท่าประกอบด้วยองค์ประกอบหลายประการ:

1. ภาพ- ชุดซอฟต์แวร์ที่กำหนดค่าโดยนักพัฒนา ซึ่งดาวน์โหลดจากเว็บไซต์ทางการ
2. คอนเทนเนอร์- การนำรูปภาพไปใช้ - เอนทิตีบนเซิร์ฟเวอร์ที่สร้างขึ้นจากคอนเทนเนอร์ คอนเทนเนอร์ไม่ควรเป็นสำเนาที่ถูกต้องและสามารถปรับเปลี่ยนได้โดยใช้ Dockerfile
3. ปริมาณ- พื้นที่บนดิสก์ที่ใช้โดยคอนเทนเนอร์และที่บันทึกข้อมูล หลังจากถอดคอนเทนเนอร์ออก ซอฟต์แวร์จะไม่เหลือ ข้อมูลสามารถนำมาใช้ในอนาคตได้

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

การจัดการคอนเทนเนอร์ Docker: ความสามารถพื้นฐาน

ติดตั้ง Docker บนเซิร์ฟเวอร์ Ubuntu หรือ Debian หากยังไม่ได้ติดตั้งตามคำแนะนำ ดีกว่าที่จะรันคำสั่งในฐานะผู้ใช้ที่ไม่มีสิทธิพิเศษผ่าน sudo

การเรียกใช้คอนเทนเนอร์ที่ง่ายที่สุดจะแสดงให้เห็นว่าทุกอย่างใช้งานได้

คำสั่งพื้นฐานสำหรับจัดการคอนเทนเนอร์

คุณสามารถแสดงคอนเทนเนอร์ที่ใช้งานอยู่ทั้งหมดเช่นนี้

ด้วยสวิตช์ -a คอนเทนเนอร์ทั้งหมดจะแสดงขึ้น รวมถึงคอนเทนเนอร์ที่ไม่ได้ใช้งาน

Dicker กำหนดชื่อให้กับคอนเทนเนอร์แบบสุ่ม หากจำเป็น คุณสามารถระบุชื่อได้โดยตรง

นักเทียบท่าวิ่ง — ชื่อสวัสดีโลก

เปิดคอนเทนเนอร์ชื่อ my-linux-container ตามอิมเมจ Ubuntu และไปที่คอนโซลคอนเทนเนอร์โดยระบุ bash shell

นักเทียบท่า run -it —name my-linux-container ubuntu bash

หากต้องการออกจากคอนเทนเนอร์และกลับสู่โฮสต์ ระบบจำเป็นต้องเรียกใช้

ภาพทั้งหมดตามคอนเทนเนอร์ที่สร้างขึ้นจะถูกดาวน์โหลดจาก hub.docker.com โดยอัตโนมัติเมื่อสร้างคอนเทนเนอร์ขึ้นครั้งแรก ภาพที่มีอยู่แล้วในเครื่องสามารถเห็นได้โดยการรันอิมเมจของนักเทียบท่า

การสร้างคอนเทนเนอร์จากภาพที่ดาวน์โหลดแล้วจะเร็วขึ้นมาก (เกือบจะในทันที)

เมื่อคุณออกจากคอนเทนเนอร์ด้วยทางออก คอนเทนเนอร์จะหยุด เพื่อไม่ให้สิ่งนี้เกิดขึ้น คุณสามารถออกด้วยแป้นพิมพ์ลัด CTRL + A + P

คุณสามารถลบคอนเทนเนอร์ทั้งหมดที่ไม่ได้ใช้งาน

นักเทียบท่า rm $ (นักเทียบท่า ps -a -f สถานะ = ออก -q)

หรือลบทีละรายการ

แทนที่จะระบุตัวระบุในคำสั่งสุดท้าย คุณสามารถระบุชื่อ

ในนักเทียบท่า คอนเทนเนอร์ได้รับการจัดการโดยใช้คำสั่งที่ใช้งานง่ายจำนวนเล็กน้อย:

ID คอนเทนเนอร์นักเทียบท่าเริ่มต้น

คอนเทนเนอร์เทียบท่าหยุด ID

ID รีสตาร์ทคอนเทนเนอร์ของนักเทียบท่า

คอนเทนเนอร์นักเทียบท่าตรวจสอบ ID

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

การสร้างอิมเมจ Docker ของคุณและใช้ Dockerfile

รูปภาพมักจะสร้างจากที่มีอยู่โดยใช้ตัวเลือกเพิ่มเติมที่ระบุใน Dockerfile

จากอูบุนตู
CMD echo "สวัสดีชาวโลก"

ขณะนี้มีการสร้างภาพใหม่ตามมาตรฐาน c อูบุนตู

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

นักเทียบท่า build -t my-ubuntu

ภาพนักเทียบท่าตอนนี้จะแสดงและอิมเมจ my-ubuntu ที่สร้างขึ้นใหม่

เรียกใช้ได้และคอนโซลจะแสดงขึ้น สวัสดีชาวโลก และนี่คือข้อแตกต่างเพียงอย่างเดียวจากภาพเริ่มต้น

โดยปกติเราต้องการกฎที่ซับซ้อนมากขึ้น ตัวอย่างเช่น เราจำเป็นต้องรวม python3 ไว้ในรูปภาพ - ไปที่ไดเร็กทอรีใหม่และสร้าง Dockerfile

จากอูบุนตู
CMD apt-get update && apt-get ติดตั้ง python3

คำแนะนำทั้งหมดเขียนในบรรทัดเดียว

นักเทียบท่า build -t my-ubuntu-with-python3.

เริ่มคอนเทนเนอร์โดยเข้าไปข้างใน

นักเทียบท่า run -it my-ubuntu-with-python3 bash

ข้างในเป็นรูทคุณต้องดำเนินการ dpkg -l | grep python3, คำสั่งจะแสดงว่า package นั้นอยู่ในระบบ แปลว่าสำเร็จ

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

Apt-get ในโลกแห่งสภาพแวดล้อมเสมือนจริง

Docker ใช้เทคโนโลยีเนมสเปซและ cgroups (อันแรกให้การแยกส่วนที่สองให้การจัดกลุ่มกระบวนการและการ จำกัด ทรัพยากร) ดังนั้นในแง่ของการจำลองเสมือนจึงไม่แตกต่างจาก LXC / OpenVZ ที่เราคุ้นเคยมากนัก มากที่จะพูดคุยเกี่ยวกับที่นี่ ความเร็วดั้งเดิมเท่ากัน วิธีการแยกเดียวกันตามกลไกเคอร์เนลของ Linux อย่างไรก็ตาม ข้างต้น เรื่องราวที่แตกต่างอย่างสิ้นเชิงเริ่มต้นขึ้น จุดเด่นของ Docker คือช่วยให้คุณสามารถปรับใช้สภาพแวดล้อมเสมือนที่เต็มเปี่ยมและเปิดแอปพลิเคชันในนั้นได้อย่างง่ายดายเช่นการรีสตาร์ทเว็บเซิร์ฟเวอร์

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

$ sudo yum ติดตั้ง docker-io $ sudo docker run -t ubuntu: ล่าสุด / usr / bin / top

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

$ sudo docker run -t -i ubuntu: ล่าสุด / bin / bash # apt-get update # apt-get ติดตั้ง nginx #

อย่างที่คุณเห็น ทุกอย่างก็เรียบร้อยสำหรับเครือข่ายเช่นกัน ดังนั้นเราจึงสามารถอัปเดตระบบ ติดตั้งและกำหนดค่าซอฟต์แวร์ใดๆ ก็ได้ ดูเหมือนเวทมนตร์ แต่จริงๆ แล้วง่ายมาก Docker เป็นประเภท apt-get ในโลกของคอนเทนเนอร์ แทนที่จะเป็นแพ็คเกจเท่านั้นที่มีอิมเมจระบบไฟล์ และแทนที่จะเป็นที่เก็บ Debian / Ubuntu อย่างเป็นทางการ ก็มีที่เก็บข้อมูลบนคลาวด์ที่เรียกว่า Docker Hub

เมื่อเราทำ "docker run ..." ระบบจะทำสิ่งต่อไปนี้:

1. ยูทิลิตีนักเทียบท่าได้ติดต่อกับ dockerd daemon บนเครื่องท้องถิ่นของเรา กล่าวทักทายจากเรา และขอให้เรียกใช้ Ubuntu เวอร์ชันล่าสุด (ตามที่ระบุโดยแท็กล่าสุดในคำสั่ง) ในคอนเทนเนอร์ที่แยกออกมา
2. dockerd daemon ตรวจสอบโน้ตบุ๊ก ไปที่ไดเร็กทอรี / var / lib / docker และพบว่าอิมเมจระบบไฟล์จาก Ubuntu ล่าสุดไม่ได้อยู่ในเครื่องของเรา จึงตัดสินใจติดต่อ Docker Hub เพื่อดูว่ามี เป็นภาพที่นั่น
3. หลังจากคุยกับ Docker Hub แล้ว เขาทำให้แน่ใจว่าภาพนั้นยังคงอยู่ และขอให้ส่งให้เรา
4. เมื่อได้รับอิมเมจที่ต้องการแล้ว dockerd ติดตั้งระบบไฟล์ สร้าง chroot เข้าไปแล้วรันคำสั่งที่ระบุในอาร์กิวเมนต์สุดท้าย จำกัด "ขอบเขต" โดยใช้เนมสเปซ (อันที่จริง มันตัดการเข้าถึงระบบไฟล์หลัก โฮสต์ กระบวนการของระบบ, IPC และอื่นๆ ถูกล็อกไว้ในแซนด์บ็อกซ์) แต่โยนไฟล์อุปกรณ์ของเทอร์มินัลปัจจุบันเข้าไป (แฟล็ก -t) เพื่อให้ส่วนบนของเราสามารถวาดอินเทอร์เฟซกราฟิกหลอกได้

จุดเด่นของรุ่นนี้คือ Docker Hub เปิดให้ทุกคนและทุกคนสามารถเตรียมอิมเมจของตัวเองได้ (เพิ่มเติมในภายหลัง) และเผยแพร่เพื่อติดตั้งในเครื่องอื่นและ / หรือโดยบุคคลอื่น ในขณะที่เขียนบทความนี้ มีการเผยแพร่รูปภาพมากกว่า 45,000 รูปบน Docker Hub สำหรับทุกโอกาส ตั้งแต่รูปภาพของการแจกจ่าย "เปล่า" ไปจนถึงรูปภาพที่มีเซิร์ฟเวอร์ที่กำหนดค่าไว้ล่วงหน้าและแอปพลิเคชันเดสก์ท็อปที่ทำงานในสภาพแวดล้อม Linux ที่เรียบง่าย

จะเป็นอย่างไรถ้าเราต้องการเรียกใช้ Firefox ภายในสภาพแวดล้อมเสมือน ง่ายกว่าที่เคย เปิด Docker Hub ในเบราว์เซอร์ คลิก เรียกดูและค้นหา แล้วพิมพ์ firefox รายการผลลัพธ์จะปรากฏขึ้นบนหน้าจอ เราดู kennethkl / firefox ดูเหมือนจะค่อนข้างเหมาะสม เราคลิกที่มันและดูข้อมูลเกี่ยวกับวิธีการเริ่มต้นสิ่งทั้งหมด ผู้เขียนบอกให้เรารันคำสั่งดังนี้:

$ sudo docker run -d --name firefox -e DISPLAY = $ DISPLAY \ -v /tmp/.X11-unix:/tmp/.X11-unix kennethkl / firefox

มาลองกัน. ใช่ หลังจากดาวน์โหลดภาพสั้นๆ เราได้รับ Firefox มาตรฐานบนหน้าจอ โดยใช้ตัวอย่างเดียวกัน คุณสามารถทำความคุ้นเคยกับตัวเลือกที่มีประโยชน์มากกว่าสี่ตัวเลือกของคำสั่ง docker run:

• -d - "daemonizes" คอนเทนเนอร์ กล่าวคือ เพียงแค่ยกเลิกการเชื่อมต่อ Docker จากสภาพแวดล้อมเสมือน STDOUT และอนุญาตให้ทำงานในพื้นหลัง
• --name - ชื่อของคอนเทนเนอร์ที่จะได้รับแทนตัวระบุ
• -e - ให้คุณ "ส่งต่อ" ตัวแปรสภาพแวดล้อมไปยังเครื่องเสมือน
• -v - ส่งต่อไฟล์หรือไดเร็กทอรีที่ระบุ (รูปแบบ / file / on / host / system: / file / in / virtual machine หรือเพียงแค่ / file / on / host / system หากเส้นทางตรงกัน)

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

มีวิธีที่ง่ายกว่าในการค้นหาอิมเมจ Docker โดยใช้คำสั่งค้นหานักเทียบท่า:

$ sudo docker ค้นหา nginx

ข้อมูล

ผู้ใช้ Docker ทุกคนสามารถเรียกใช้ Hub ส่วนตัวของตนเองได้ เรียกว่า "รีจิสตรี" และพร้อมใช้งานในรูปแบบภาพสำเร็จรูป สิ่งที่คุณต้องทำคือเรียกใช้: docker run -p 5555: 5555 Registry

Docker daemon ใช้งานได้ไม่เฉพาะกับไคลเอนต์เท่านั้น แต่ยังใช้ RESTful API ได้ทั้งในเครื่องและจากเครื่องระยะไกล พอร์ต Docker มาตรฐานคือ tcp / 2375 e tcp / 2376

อิมเมจ Docker ไม่จำเป็นต้องรันทันทีหลังจากดาวน์โหลด คุณสามารถดาวน์โหลดอิมเมจ Docker ลงในเครื่องของคุณก่อนโดยใช้คำสั่ง docker pull จากนั้นรันเท่านั้น: docker pull ubuntu

เค้กชั้น

Docker ช่วยให้คุณทำงานในสภาพแวดล้อมเสมือนได้สะดวกที่สุด ลดความซับซ้อนทั้งกระบวนการปรับใช้สภาพแวดล้อมและการตั้งค่าการโต้ตอบกับระบบโฮสต์ (ซึ่งเป็นเพียงตัวอย่างสุดท้าย) แต่นี่ไม่ใช่ไฮไลท์เพียงอย่างเดียว

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

ความจริงก็คือว่าในกรณีส่วนใหญ่ "อิมเมจ Docker" ไม่ใช่อิมเมจระบบไฟล์แบบเสาหินเลย แต่เป็นเลเยอร์เค้กชนิดหนึ่งที่ประกอบด้วยอิมเมจระบบไฟล์หลายภาพ บนพื้นฐานของการสร้างคอนเทนเนอร์ ในเวลาเดียวกัน อิมเมจ FS แต่ละรายการจะไม่รับผิดชอบต่อบางส่วนของโครงสร้างไดเร็กทอรีเลย (เช่น ในกรณีของการแบ่งพาร์ติชั่นดิสก์ภายใต้ Linux ออกเป็นพาร์ติชั่น / home, / var, / boot) แต่เป็นเลเยอร์ ทับกันโดยใช้กลไกเคอร์เนล AUFS ลินุกซ์ (นอกจากนี้ยังรองรับการทำงานแบบเดียวกันผ่านการใช้ btrfs, ตัวแมปอุปกรณ์ และโอเวอร์เลย์)

เพื่อให้เข้าใจวิธีการทำงาน ให้กลับไปที่คอนเทนเนอร์ Ubuntu ของเรา เราเริ่มคอนเทนเนอร์และติดตั้ง nginx ตามที่แสดงในตัวอย่างที่สองที่จุดเริ่มต้นของบทความ แต่อย่ายุติมัน แต่เราเปิดเทอร์มินัลอื่นและดูรายการคอนเทนเนอร์ที่ทำงานอยู่:

$ sudo นักเทียบท่า ps

คำสั่งนี้จะแสดงคอนเทนเนอร์ที่กำลังทำงานอยู่ทั้งหมดพร้อมกับ ID, รูปภาพที่ใช้, คำสั่งที่เปิดใช้, เวลาทำงาน และอื่นๆ เราสนใจค่าในคอลัมน์ CONTEINER ID คัดลอกและรันคำสั่งต่อไปนี้:

$ sudo docker ยอมรับรหัสคอนเทนเนอร์ ubuntu-nginx

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

$ sudo docker run -i -t ubuntu-nginx / bin / bash # ซึ่ง nginx / usr / sbin / nginx

เราทำอะไรลงไปบ้าง? เราได้สร้างเลเยอร์อื่น นั่นคือ อิมเมจ FS เพิ่มเติม และสร้างอิมเมจ Docker ใหม่โดยอิงจากอิมเมจ Ubuntu Docker ที่มีอยู่แล้ว รวมถึงอิมเมจ FS ของเราซึ่งมี nginx ฟังดูสับสนเล็กน้อยใช่ไหม จริงๆแล้วมันค่อนข้างง่าย

เราพบว่าแต่ละอิมเมจ Docker ประกอบด้วยอิมเมจระบบไฟล์หลายอิมเมจ เมื่อเราเริ่มคอนเทนเนอร์ อิมเมจเหล่านี้จะถูกเมาท์และประกอบเป็นโครงสร้างไดเร็กทอรีเดียวโดยใช้ AUFS ตัวอย่างเช่น อิมเมจแรกสามารถมีได้เฉพาะการติดตั้ง Ubuntu พื้นฐาน อันที่สองเพิ่มชุดของ daemon มาตรฐาน อันที่สาม - ยูทิลิตีการดูแลระบบ และอื่นๆ Docker ติดตั้งเลเยอร์ทั้งหมดในโหมดอ่านอย่างเดียว แต่เพื่อให้เราสามารถเปลี่ยนเนื้อหาของรูปภาพได้ เลเยอร์ว่างอื่นในตอนแรกจะถูกเชื่อมต่อที่ด้านบนสุดในโหมดอ่าน/เขียน

โดยค่าเริ่มต้น หลังจากที่คอนเทนเนอร์เสร็จสิ้น (ซึ่งเกิดขึ้นหลังจากกระบวนการสุดท้ายที่ทำงานอยู่ในนั้น) เลเยอร์สุดท้ายจะถูกลบและการเปลี่ยนแปลงทั้งหมดของเราจะหายไป อย่างไรก็ตาม เมื่อใช้คำสั่ง docker commit เราสามารถ "กระทำ" การเปลี่ยนแปลงได้โดยการสร้างอิมเมจ Docker ใหม่ตามอิมเมจ FS ที่มีอยู่ บวกกับอิมเมจ FS ด้วยการเปลี่ยนแปลงของเรา การดำเนินการนี้จะบันทึกการเปลี่ยนแปลงที่เราทำ อีกทางเลือกหนึ่ง เราสามารถเริ่มคอนเทนเนอร์ ubuntu-nginx ทำการเปลี่ยนแปลง และในทำนองเดียวกันให้บันทึกไปยังอิมเมจ Docker ใหม่โดยใช้คอมมิต เพิ่มเลเยอร์อื่น คุณสามารถใช้คำสั่ง docker images เพื่อดูรายการของภาพที่ได้ทั้งหมด (และจาก Docker Hub) และคำสั่ง docker history เพื่อดูประวัติของการสร้างเลเยอร์:

$ sudo docker history ubuntu-nginx

วิธีการสร้างอิมเมจนี้ให้ความยืดหยุ่นมากขึ้นในการจัดการคอนเทนเนอร์ ประหยัดเวลาได้มาก และช่วยให้คุณถ่ายโอนอิมเมจ Docker ที่กำหนดค่าไว้แล้วระหว่างเครื่องได้อย่างง่ายดาย (สามารถอัปโหลดอิมเมจไปยัง Docker Hub แล้วนำไปปรับใช้กับเครื่องอื่นได้) ข้อดีที่ชัดเจนน้อยกว่าคือการประหยัดพื้นที่ดิสก์ หากเราปรับใช้สวนสัตว์ทั้งตู้คอนเทนเนอร์บนเครื่อง ซึ่งแต่ละอันจะอิงตามอิมเมจฐานเดียวในขั้นต้น (เช่น Ubuntu เดียวกัน) - พวกมันทั้งหมดจะอ้างถึงอิมเมจพื้นฐานนี้และจะไม่ทำซ้ำเนื้อหา

นักเทียบท่านอก Linux

วิธีเดียวที่จะเรียกใช้ Docker บน OS X หรือ Windows คือการติดตั้งในเครื่องเสมือน คุณไม่จำเป็นต้องดำเนินการด้วยตนเอง คุณสามารถใช้โซลูชันสำเร็จรูปได้ เช่น boot2docker นี่คือชุดของสคริปต์ที่ให้คุณปรับใช้เครื่องเสมือน Linux และ Docker ภายใน VirtualBox ได้อย่างรวดเร็ว และเริ่มต้นใช้งานด้วยการเข้าถึง SSH อัตโนมัติ คำแนะนำในการใช้งานและตัวติดตั้งสามารถพบได้บนเว็บไซต์ทางการของ Docker

การกำหนดค่าเครือข่าย

เพื่อให้คอนเทนเนอร์สามารถสื่อสารระหว่างกันและกับโลกภายนอก Docker จะยกบริดจ์เครือข่ายเสมือนโดยอัตโนมัติและกำหนดค่ากฎการปลอมแปลง (NAT) สำหรับอินเทอร์เฟซเครือข่ายภายนอก ซึ่งหมายความว่าจะไม่สามารถเข้าถึงภาชนะจากภายนอกได้ อย่างไรก็ตาม เราสามารถกำหนดค่าการส่งต่อพอร์ตเพื่อให้คำขอไปยังพอร์ตเฉพาะบนอินเทอร์เฟซเครือข่ายภายนอกของเครื่องถูกเปลี่ยนเส้นทางไปยังพอร์ตคอนเทนเนอร์ที่ระบุโดยอัตโนมัติ ตัวอย่างเช่น ที่ Mirantis โหนดเชื้อเพลิงหลัก (นี่คือ GUI สำหรับการปรับใช้และกำหนดค่า OpenStack) ทำงานใน Docker และใช้การส่งต่อพอร์ตเพื่อเปิดการเข้าถึงคอนเทนเนอร์ ful / nginx (พอร์ต 8000):

$ sudo docker run -d -p 8000: 8000 เชื้อเพลิง / nginx_6.0: ล่าสุด /usr/local/bin/start.sh

เราสามารถส่งต่อพอร์ต 8000 ไปยังพอร์ตอื่น ๆ ของคอนเทนเนอร์ได้โดยเพียงแค่เปลี่ยนหมายเลขที่สองในตัวเลือก -p แต่สิ่งนี้ไม่สมเหตุสมผลในการกำหนดค่านี้

การส่งต่อไฟล์และ Dockerfile

ในตอนต้นของบทความ เราได้ทำความคุ้นเคยกับแฟล็ก -v แล้ว ซึ่งช่วยให้คุณส่งต่อไฟล์หรือไดเร็กทอรีใดๆ จากระบบโฮสต์ไปยังคอนเทนเนอร์ได้ นี่เป็นฟังก์ชันที่สะดวกมาก สามารถใช้ได้ทั้งสำหรับการจัดเก็บข้อมูลชั่วคราวบางส่วน และสำหรับการแชร์ไฟล์ระหว่างคอนเทนเนอร์ต่างๆ ใน Mirantis ฟังก์ชันนี้ใช้เพื่อส่งต่อไฟล์การกำหนดค่าสำหรับบริการ Fuel / astute (/ etc / astute) ภายในคอนเทนเนอร์:

$ sudo docker run -d -v / etc / เชื้อเพลิงที่ชาญฉลาด / astute_6.0: ล่าสุด /usr/local/bin/start.sh

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

จากเชื้อเพลิง / centos MAINTAINER Matthew Mosesohn [ป้องกันอีเมล]รัน rm -rf /etc/yum.repos.d / *; \ echo -e "\ nname = Nailgun Local Repo \ nbaseurl = http: // $ (route -n | awk" /^0.0.0.0/ (พิมพ์ $ 2 ) "): _ PORT_ / os / x86_64 / \ ngpgcheck = 0"> /etc/yum.repos.d/nailgun.repo; \ yum clean all; \ yum --quiet install -y ruby21-nailgun-mcagents sysstat เพิ่ม ฯลฯ / ฯลฯ เพิ่ม start.sh /usr/local/bin/start.sh เรียกใช้หุ่นกระบอก --detailed-exitcodes -d -v /etc/puppet/modules/nailgun/examples/astute-only.pp; [[$? == 0 || $? == 2]] RUN chmod + x /usr/local/bin/start.sh; \ echo -e "\ nname = Nailgun Local Repo \ nbaseurl = ไฟล์: / var / www / nailgun / centos / x86_64 \ ngpgcheck = 0 "> /etc/yum.repos.d/nailgun.repo; yum clean all VOLUME / etc / ฉลาด CMD /usr/local/bin/start.sh

ไม่ยากที่จะเข้าใจว่ามีไว้เพื่ออะไร มันสร้างรูปภาพตามเชื้อเพลิง / centos เรียกใช้คำสั่งต่าง ๆ เพื่อเตรียมรูปภาพ เพิ่มไฟล์จากไดเร็กทอรีปัจจุบันไปยังรูปภาพ ใช้รายการ Puppet เปลี่ยนการอนุญาตในบางไฟล์ ส่งต่อไดเร็กทอรี / etc / asture / จากโฮสต์ ระบบไปยังคอนเทนเนอร์ และเริ่มคอนเทนเนอร์โดยใช้คำสั่ง /usr/local/bin/start.sh

ในการสร้างคอนเทนเนอร์ เพียงแค่ใส่ Dockerfile และไฟล์ทั้งหมดที่จะเพิ่มลงในไดเร็กทอรีและรันคำสั่งต่อไปนี้:

$ sudo docker build fuel / astute_6.0: ล่าสุด

ในกรณีนี้เราเลือกชื่อ Fuel / astute_6.0: ล่าสุด ถึงแม้ว่าจะเป็นอะไรก็ได้

ความแตกต่างของการทำงานร่วมกับ Docker

Docker สร้างขึ้นจากแนวคิดที่ว่าควรเรียกใช้บริการเดียวเท่านั้นในแต่ละคอนเทนเนอร์ คุณทำแพ็กเกจ Apache, MySQL, nginx, Varnish และสิ่งที่โครงการของคุณต้องการลงในคอนเทนเนอร์ต่างๆ จากนั้นใช้ Docker เพื่อสร้างทั้งหมดเข้าด้วยกัน แนวทางนี้มีความยืดหยุ่นสูง เนื่องจากช่วยให้คุณเปลี่ยนการกำหนดค่า ทดสอบการอัปเดต และย้ายบริการแต่ละรายการไปยังเครื่องอื่นๆ ได้อย่างง่ายดาย

ด้วยเหตุผลเดียวกัน จึงไม่ใช่เรื่องปกติที่จะใช้ Docker เพื่อรันสภาพแวดล้อม Linux เต็มรูปแบบด้วย init daemon, cron และ syslog daemons และส่วนประกอบการแจกจ่ายมาตรฐานอื่นๆ แต่เราเพิ่งเริ่มบริการที่เราต้องการและทำงานในสภาพแวดล้อมเสมือนจริงเพียงอย่างเดียว:

$ sudo docker run -d -p 80 ubuntu-nginx / usr / sbin / nginx

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

ในกรณีของ nginx คุณสามารถแก้ไขปัญหานี้ได้โดยการเพิ่ม daemon off บรรทัดแรกในการกำหนดค่า daemons อื่น ๆ จะต้องมีการตั้งค่าของตัวเอง และบางอันสามารถป้องกันไม่ให้ daemonizing โดยตรงจากบรรทัดคำสั่ง ตัวอย่างเช่น sshd จัดเตรียมแฟล็ก -D สำหรับสิ่งนี้:

$ sudo docker run -d -p 22 ubuntu-ssh / usr / sbin / sshd -D

คุณสามารถเชื่อมต่อกับคอนเทนเนอร์ได้ตลอดเวลาโดยใช้คำสั่ง docker exec เพื่อดูบันทึกหรือเปลี่ยนการตั้งค่า (ต่อไปนี้ ID คอนเทนเนอร์คือ ID ที่สามารถมองเห็นได้ในเอาต์พุตของ docker ps หรือชื่อที่ระบุที่ เริ่มต้นใน --name ตัวเลือก ):

$ sudo docker exec -ti รหัสคอนเทนเนอร์ / bin / bash

แต่ยังมีอุปสรรค์เล็ก ๆ อยู่ที่นี่ ดังที่เราทราบ ข้อมูลทั้งหมดที่สะสมระหว่างการทำงานของสภาพแวดล้อมเสมือนจะสูญหายไปหากเรายุติการทำงานของสภาพแวดล้อมเสมือน และด้วยข้อมูลดังกล่าว บันทึกและการเปลี่ยนแปลงที่เกิดขึ้นกับการตั้งค่าจะหายไป เรายังไม่สามารถสร้างเลเยอร์ได้ไม่รู้จบ (ถ้าเพียงเพราะว่ามีได้ไม่เกิน 127 เลเยอร์) แต่เราสามารถใช้เส้นทางที่แตกต่างกันเล็กน้อยและใช้ระบบการรวมบันทึกที่มีอยู่ใน Docker แน่นอนว่า Docker ไม่สามารถรวบรวมบันทึกของแอปพลิเคชันแต่ละรายการได้ แต่สามารถรวบรวมเอาต์พุต STDOUT ได้ นั่นคือเอาต์พุตของคอนโซลใดๆ สิ่งที่เหลืออยู่สำหรับเราคือเปลี่ยนการกำหนดค่า nginx เพื่อให้บันทึกถูกเทลงใน / dev / stdout จากนั้นดูโดยใช้คำสั่ง docker logs:

$ sudo docker บันทึก ID คอนเทนเนอร์

อีกตัวเลือกหนึ่งที่ถูกต้องมากขึ้นคือเพียงแค่ย้ายบันทึก (และหากจำเป็น ให้ตั้งค่าการตั้งค่า) ไปยังระบบโฮสต์โดยใช้ตัวเลือก -v ที่อธิบายไว้แล้ว:

$ sudo mkdir / root / logs $ sudo docker run -d -v / root / logs: / var / logs -p 80 ubuntu-nginx / usr / sbin / nginx

หากจำเป็น สามารถหยุดคอนเทนเนอร์ได้อย่างถูกต้องโดยยุติบริการที่ทำงานอยู่ในนั้นโดยใช้คำสั่งหยุดเทียบท่า:

$ sudo docker หยุด ID คอนเทนเนอร์

และถ้ามันทำงานไม่ถูกต้องด้วยเหตุผลบางอย่าง คุณสามารถฆ่ามันด้วยการฆ่า:

$ sudo docker ฆ่า ID คอนเทนเนอร์

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

$ sudo docker เริ่ม ID คอนเทนเนอร์

หากคุณไม่ต้องการบันทึกสถานะ (เช่น สำหรับการทดสอบหรือตรวจสอบการทำงานบางอย่าง) คุณสามารถใช้แฟล็ก --rm ซึ่งจะบังคับให้ Docker ทำลายคอนเทนเนอร์ทั้งหมดหลังจากเสร็จสิ้น (การบันทึกภาพ):

$ sudo docker run --rm -i -t busybox / bin / bash

คุณสามารถทำลายคอนเทนเนอร์ที่บันทึกไว้ก่อนหน้านี้ทั้งหมดโดยใช้คำสั่งต่อไปนี้:

# นักเทียบท่า rm $ (นักเทียบท่า ps -a -q)

นักเทียบท่าสามารถรีสตาร์ทคอนเทนเนอร์ได้อย่างอิสระหากเกิดปัญหาและแม้กระทั่งเริ่มต้นระหว่างการเริ่มต้นระบบ สิ่งที่คุณต้องทำคือใช้ตัวเลือก --restart:

$ sudo docker run --restart = always \ -d -v / root / logs: / var / logs -p 80 \ ubuntu-nginx / usr / sbin / nginx

สามารถส่งออกรูปภาพเป็นไฟล์เดียวแล้วนำเข้าไปยังเครื่องอื่นได้ตลอดเวลา คำสั่ง docker save และ docker restore มีให้สำหรับสิ่งนี้ มันใช้งานง่ายมาก การส่งออกทำได้ดังนี้:

$ sudo docker save -o ubuntu-nginx.img ubuntu-nginx

และการนำเข้าจะเป็นดังนี้:

$ sudo docker load -i ubuntu-nginx.img

ข้อสรุป

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

ข้อดีของ Docker เหนือ LXC, OpenVZ และโซลูชันการจำลองเสมือนระดับ OS อื่นๆ

1. นักเทียบท่าใช้รูปแบบภาพทั่วไปแบบพกพา ซึ่งหมายความว่าภาพเหล่านี้สามารถถ่ายโอนไปยังเครื่องอื่นได้โดยไม่มีปัญหาใดๆ และแชร์ให้ผู้ใช้รายอื่นใช้งานได้
2. รูปภาพสามารถใช้เป็นฐานสำหรับรูปภาพอื่นๆ ใน Docker เป็นเรื่องปกติที่จะใช้หลายเลเยอร์เพื่อสร้างภาพสุดท้าย คุณสามารถเริ่มต้นด้วยอิมเมจพื้นฐานของ Ubuntu จากนั้นเพิ่ม Apache 2.4 เพื่อสร้างไมโครเซอร์วิส Ubuntu + Apache
3. เมื่อคุณคอมมิต รูปภาพสามารถกำหนดเวอร์ชันได้ เช่นเดียวกับใน GIT
4. Docker มีชุมชนขนาดใหญ่และระบบนิเวศที่ครอบคลุมซึ่งมีเครื่องมือจำนวนมากสำหรับการปรับขนาด การจัดกลุ่ม การเฝ้าติดตาม การปรับใช้ และการจัดการคอนเทนเนอร์

เราได้กล่าวถึงหัวข้อนี้มากกว่าหนึ่งครั้งและได้พิจารณาระบบต่างๆ มากมายสำหรับการก่อสร้าง วันนี้เราจะมาแนะนำระบบที่ยอดเยี่ยมอีกระบบหนึ่งด้วยคอนเทนเนอร์ Docker

เริ่มต้นด้วยการอธิบายฟังก์ชันพื้นฐานที่จะเป็นประโยชน์ในบทความเพิ่มเติมในซีรีส์นี้ และเรียกใช้สถาปัตยกรรม Docker สั้นๆ นักเทียบท่าใช้สถาปัตยกรรมไคลเอนต์ - เซิร์ฟเวอร์และประกอบด้วยไคลเอนต์ - ยูทิลิตี้นักเทียบท่าที่เข้าถึงเซิร์ฟเวอร์โดยใช้ RESTful APIและภูตในระบบปฏิบัติการ Linux (ดูรูปที่ 1) แม้ว่า Docker จะทำงานบนระบบปฏิบัติการที่ไม่ใช่ Linux แต่ก็ไม่ได้กล่าวถึงในบทความนี้

ส่วนประกอบหลักของ Docker:

• ตู้คอนเทนเนอร์- สภาพแวดล้อมของผู้ใช้ที่แยกได้โดยใช้เทคโนโลยีระบบปฏิบัติการ ซึ่งแอปพลิเคชันถูกเรียกใช้งาน วิธีที่ง่ายที่สุดคือการกำหนดคอนเทนเนอร์ Docker เป็นแอปพลิเคชันที่เรียกใช้จากรูปภาพ อย่างไรก็ตาม นี่คือสิ่งที่ Docker แตกต่างในอุดมคติจากตัวอย่างจาก LXC ( คอนเทนเนอร์ลินุกซ์) แม้ว่าจะใช้เทคโนโลยีเคอร์เนล Linux เดียวกันก็ตาม ผู้พัฒนาโครงการ Docker ยึดมั่นในหลักการที่ว่าคอนเทนเนอร์เดียวคือแอปพลิเคชันเดียว
• รูปภาพ- เทมเพลตแอปพลิเคชันแบบอ่านอย่างเดียว สามารถเพิ่มระดับใหม่บนรูปภาพที่มีอยู่ ซึ่งเป็นตัวแทนของระบบไฟล์ การแก้ไข หรือเสริมระดับก่อนหน้า โดยปกติ รูปภาพใหม่จะถูกสร้างขึ้นโดยการบันทึกคอนเทนเนอร์ที่กำลังทำงานอยู่แล้วไปยังรูปภาพใหม่ทับรูปภาพที่มีอยู่ หรือโดยการใช้คำแนะนำพิเศษสำหรับยูทิลิตี้ หากต้องการแยกระดับต่างๆ ของคอนเทนเนอร์ที่ระดับระบบไฟล์ AUFS, btrfs, vfs และ Device Mapper... หากคุณต้องการใช้ Docker ร่วมกับ เซลินุกซ์แล้วมันจำเป็น อุปกรณ์ทำแผนที่
• ทะเบียนมีที่เก็บ ( ที่เก็บ) ภาพ - การจัดเก็บภาพเครือข่าย สามารถเป็นได้ทั้งแบบส่วนตัวและแบบสาธารณะ ทะเบียนที่มีชื่อเสียงที่สุดคือ

ระบบปฏิบัติการ GNU / Linux ใช้เทคโนโลยีเคอร์เนลมาตรฐานของ Linux เพื่อแยกคอนเทนเนอร์ เช่น:

• เนมสเปซ ( ลินุกซ์ เนมสเปซ).
• กลุ่มควบคุม ( Cgroups).
• เครื่องมือการจัดการสิทธิ์ ( ความสามารถของลินุกซ์).
• ระบบรักษาความปลอดภัยเพิ่มเติมที่จำเป็น เช่น AppArmor หรือ SELinux

ลองพิจารณาเทคโนโลยีที่ระบุไว้ในรายละเอียดเพิ่มเติมเล็กน้อย

กลไกกลุ่มควบคุม (ซีกรุ๊ป)จัดเตรียมเครื่องมือสำหรับปรับแต่งการจัดสรร การจัดลำดับความสำคัญ และการจัดการทรัพยากรระบบ กลุ่มควบคุมถูกนำมาใช้ในเคอร์เนลลินุกซ์ ในการแจกแจงแบบสมัยใหม่ การจัดการกลุ่มควบคุมจะดำเนินการผ่าน systemdอย่างไรก็ตาม ยังคงสามารถควบคุมได้โดยใช้ไลบรารี libcgroupและสาธารณูปโภค cgconfig... ลำดับชั้น cgroup หลัก (เรียกอีกอย่างว่าตัวควบคุม) มีการระบุไว้ด้านล่าง:

• blkio- กำหนดข้อจำกัดในการดำเนินการอินพุต-เอาท์พุตและการเข้าถึงอุปกรณ์บล็อก
• ซีพียู- ใช้ตัวกำหนดตารางเวลาของกระบวนการ กระจายเวลาของตัวประมวลผลระหว่างงาน
• cpuacct- สร้างรายงานอัตโนมัติเกี่ยวกับการใช้ทรัพยากร CPU ทำงานร่วมกับคอนโทรลเลอร์ ซีพียูอธิบายไว้ข้างต้น;
• ซีพียู- กำหนดโปรเซสเซอร์และโหนดหน่วยความจำบางอย่างให้กับงาน
• อุปกรณ์- ควบคุมการเข้าถึงงานไปยังอุปกรณ์เฉพาะ
• ตู้แช่- ระงับหรือทำงานต่อ
• หน่วยความจำ- กำหนดขีดจำกัดและสร้างรายงานเกี่ยวกับการใช้หน่วยความจำตามงานของกลุ่มควบคุม
• net_cls- ดำเนินการติดแท็กของแพ็กเก็ตเครือข่ายด้วยตัวระบุคลาส ( classid). สิ่งนี้ทำให้ผู้ควบคุมการจราจร ( คำสั่ง tc) และไฟร์วอลล์ ( iptables) พิจารณาแท็กเหล่านี้เมื่อประมวลผลการรับส่งข้อมูล
• perf_event- ให้คุณตรวจสอบกลุ่มควบคุมโดยใช้ยูทิลิตี้ สมบูรณ์แบบ;
• hugetlb- ให้คุณใช้เพจหน่วยความจำเสมือนขนาดใหญ่และใช้ขีดจำกัดได้

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

ตัวอย่างเนมสเปซที่ใช้โดย Docker:

• PID, ID กระบวนการ- การแยกลำดับชั้นของกระบวนการ
• NET, ระบบเครือข่าย- การแยกส่วนต่อประสานเครือข่าย
• พีซี, การสื่อสารระหว่างกระบวนการ- การจัดการปฏิสัมพันธ์ระหว่างกระบวนการ
• MNT, ภูเขา- การจัดการจุดเมานท์
• UTS, ระบบ Unix Timesharing- การแยกเคอร์เนลและตัวระบุเวอร์ชัน

กลไกที่เรียกว่า ความสามารถอนุญาตให้คุณแบ่งสิทธิ์ของผู้ใช้รูทออกเป็นกลุ่มเล็กๆ ของสิทธิ์และกำหนดแยกกัน ฟังก์ชันนี้ปรากฏใน GNU / Linux ตั้งแต่เวอร์ชัน เมล็ด 2.2เริ่มแรก คอนเทนเนอร์เริ่มต้นด้วยชุดสิทธิ์ที่จำกัด

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

• การดำเนินการเมานต์
• การเข้าถึงซ็อกเก็ต
• ดำเนินการบางอย่างบนระบบไฟล์ เช่น การเปลี่ยนแอ็ตทริบิวต์ของไฟล์หรือเจ้าของ

คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับสิทธิพิเศษได้โดยใช้หน้าคน ความสามารถ (7).

การติดตั้ง Docker

มาดูการติดตั้ง Docker โดยใช้ CentOS เป็นตัวอย่าง เมื่อทำงานกับ CentOS คุณมีตัวเลือก: ใช้เวอร์ชันล่าสุดจาก u สตรีมหรือเวอร์ชันที่สร้างโดยโปรเจ็กต์ CentOS ที่มีส่วนเสริมของ Red Hat คำอธิบายของการเปลี่ยนแปลงมีอยู่ในหน้า

โดยพื้นฐานแล้ว นี่คือการพอร์ตย้อนกลับของการแก้ไขจากเวอร์ชันอัปสตรีมใหม่และการเปลี่ยนแปลงที่เสนอโดยนักพัฒนา Red Hat แต่ยังไม่ได้รับการยอมรับในโค้ดหลัก ความแตกต่างที่เห็นได้ชัดเจนที่สุดในขณะที่เขียนบทความนี้คือในเวอร์ชันที่ใหม่กว่า บริการนักเทียบท่าถูกแบ่งออกเป็นสามส่วน: a daemon นักเทียบท่า ตู้คอนเทนเนอร์ และ runc... เร้ดแฮทยังไม่ถือว่าการเปลี่ยนแปลงนี้มีเสถียรภาพและจัดส่งเวอร์ชัน 1.10 ที่ปฏิบัติการได้แบบเสาหิน

การตั้งค่าที่เก็บสำหรับการติดตั้ง เวอร์ชันต้นน้ำรวมถึงคำแนะนำสำหรับการติดตั้งบนระบบปฏิบัติการและระบบปฏิบัติการอื่น ๆ มีให้ในคู่มือการติดตั้งบนเว็บไซต์ทางการ โดยเฉพาะการตั้งค่าสำหรับที่เก็บ CentOS 7:

# cat /etc/yum.repos.d/docker.repo name = Docker Repository baseurl = https: //yum.dockerproject.org/repo/main/centos/7 เปิดใช้งาน = 1 gpgcheck = 1 gpgkey = https: // yum .dockerproject.org / gpg

ติดตั้งแพ็คเกจที่จำเป็นและเริ่มและเปิดใช้งานบริการ:

# yum ติดตั้ง -y docker-engine # systemctl เริ่ม docker.service # systemctl เปิดใช้งาน docker.service

การตรวจสอบสถานะการบริการ:

# สถานะ systemctl docker.service

คุณยังสามารถดูข้อมูลระบบเกี่ยวกับ Docker และสภาพแวดล้อมได้:

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

# ls -lh / var / lib / นักเทียบท่า / devicemapper / devicemapper / data -rw ------- 1 root root 100G 27 ธันวาคม 12:00 / var / lib / docker / devicemapper / devicemapper / data

ตัวเลือกการเริ่มต้น daemon ตามปกติใน CentOS จะถูกเก็บไว้ใน / ฯลฯ / sysconfig /... ในกรณีนี้ ชื่อของไฟล์นักเทียบท่า บรรทัดที่สอดคล้องกัน / etc / sysconfig / นักเทียบท่าอธิบายตัวเลือก:

OPTIONS = "- เปิดใช้งาน selinux --log-driver = journald"

หากคุณรันคำสั่งนักเทียบท่าในฐานะผู้ใช้ที่ไม่ใช่รูทหรือสมาชิกของกลุ่มนักเทียบท่า คุณจะเห็นข้อผิดพลาดดังนี้:

$ นักเทียบท่าค้นหา mysql

คำเตือน: ไม่สามารถรับปลายทางรีจิสทรีเริ่มต้นจาก daemon (ไม่สามารถเชื่อมต่อกับ Docker daemon ได้ docker daemon ทำงานบนโฮสต์นี้หรือไม่) การใช้ค่าเริ่มต้นของระบบ: https: // ดัชนี นักเทียบท่า.io/v1/

ไม่สามารถเชื่อมต่อกับ Docker daemon docker daemon ทำงานบนโฮสต์นี้หรือไม่

โปรดทราบว่าการเพิ่มผู้ใช้ในกลุ่มนักเทียบท่านั้นเท่ากับการเพิ่มผู้ใช้นั้นในกลุ่มรูท

นักพัฒนา RHEL / CentOS มีแนวทางที่แตกต่างกันเล็กน้อยในการรักษาความปลอดภัย Docker daemon กว่านักพัฒนา Docker ต้นน้ำเอง สำหรับข้อมูลเพิ่มเติมเกี่ยวกับแนวทางของ Red Hat โปรดดูบทความโดย Dan Walsh ผู้พัฒนา RHEL

หากคุณต้องการให้พฤติกรรม "มาตรฐาน" ของ Docker ติดตั้งจากที่เก็บ CentOS (ซึ่งอธิบายไว้ในเอกสารประกอบอย่างเป็นทางการ) คุณต้องสร้างกลุ่มนักเทียบท่าและเพิ่มตัวเลือกเริ่มต้นของ daemon:

OPTIONS = "- เปิดใช้งาน selinux --log-driver = journald ↵ --group = นักเทียบท่า"

จากนั้นเราเริ่มบริการใหม่และตรวจสอบว่าไฟล์ซ็อกเก็ตนักเทียบท่าเป็นของกลุ่มนักเทียบท่าไม่ใช่รูท:

การค้นหารูปภาพและแท็ก Docker

ลองหาคอนเทนเนอร์บน Docker Hub กัน

$ docker ค้นหา haproxy

ในผลลัพธ์นี้ เราได้รับรายการอิมเมจ HA Proxy จำนวนหนึ่ง รายการบนสุดในรายการคือ HA Proxy จากที่เก็บอย่างเป็นทางการ ภาพดังกล่าวแตกต่างกันตรงที่ไม่มีสัญลักษณ์อยู่ในชื่อ «/» การแยกชื่อที่เก็บของผู้ใช้ออกจากชื่อของคอนเทนเนอร์เอง ตัวอย่างเบื้องหลังอย่างเป็นทางการแสดงสองภาพ haproxy จากที่เก็บผู้ใช้ที่เปิดอยู่ eeacms และล้าน12.

ภาพเหมือนสองภาพด้านล่างนี้ คุณสามารถสร้างตัวเองได้โดยการลงทะเบียนบน Docker Hub อย่างเป็นทางการได้รับการสนับสนุนจากทีมงานเฉพาะที่ได้รับการสนับสนุนจาก Docker, Inc. คุณสมบัติของที่เก็บอย่างเป็นทางการ:

• ภาพเหล่านี้เป็นภาพที่แนะนำให้ใช้ โดยยึดตามแนวทางปฏิบัติที่ดีที่สุดและแนวทางปฏิบัติที่ดีที่สุด
• เป็นภาพพื้นฐานที่สามารถเป็นจุดเริ่มต้นสำหรับการปรับแต่งเพิ่มเติม ตัวอย่างเช่น อิมเมจพื้นฐานของ Ubuntu, CentOS หรือไลบรารีและสภาพแวดล้อมการพัฒนา
• ประกอบด้วยซอฟต์แวร์เวอร์ชันล่าสุดที่มีช่องโหว่คงที่
• เป็นช่องทางการจำหน่ายสินค้าอย่างเป็นทางการ หากต้องการค้นหารูปภาพที่เป็นทางการเท่านั้น คุณสามารถใช้ตัวเลือก –Filter “เป็นทางการ = จริง”คำสั่ง ค้นหานักเทียบท่า.

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

ดาวน์โหลดอิมเมจ HA Proxy อย่างเป็นทางการ:

$ docker pull haproxy ใช้แท็กเริ่มต้น: ล่าสุด

ชื่อเต็มของรูปภาพอาจมีลักษณะดังนี้:

[ชื่อผู้ใช้] ชื่อภาพ [: แท็ก]

คุณสามารถดูรายการรูปภาพที่ดาวน์โหลดด้วยคำสั่ง ภาพนักเทียบท่า:

เปิดตัวตู้คอนเทนเนอร์

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

$ docker run -it ubuntu [ป้องกันอีเมล]:/#

นอกจากทีมงาน วิ่งเราได้ระบุสองตัวเลือก: -ผม- คอนเทนเนอร์ควรทำงานแบบโต้ตอบและ -NS- ต้องเน้นเทอร์มินัลหลอก ดังที่คุณเห็นจากผลลัพธ์ เรามีสิทธิ์ผู้ใช้รูทในคอนเทนเนอร์ และ ID คอนเทนเนอร์จะแสดงเป็นชื่อโฮสต์ หลังอาจไม่เป็นจริงสำหรับคอนเทนเนอร์ทั้งหมดและขึ้นอยู่กับผู้พัฒนาคอนเทนเนอร์ ให้ตรวจสอบว่านี่เป็นสภาพแวดล้อมของ Ubuntu หรือไม่:

[ป้องกันอีเมล]: / # cat / etc / * ปล่อย | grep DISTRIB_DESCRIPTION DISTRIB_DESCRIPTION = "อูบุนตู 16.04.1 LTS"

คำสั่ง Unname -NSสำหรับวัตถุประสงค์ดังกล่าว มันจะไม่ทำงาน เนื่องจากคอนเทนเนอร์ทำงานกับเคอร์เนลของโฮสต์

หนึ่งในตัวเลือกอาจเป็นชื่อคอนเทนเนอร์เฉพาะที่สามารถอ้างอิงได้เพื่อความสะดวก นอกเหนือจาก รหัสคอนเทนเนอร์มอบให้เป็น -ชื่อ<имя>. หากละเว้นตัวเลือก ชื่อจะถูกสร้างขึ้นโดยอัตโนมัติ

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

คุณสามารถดูรายการคอนเทนเนอร์ที่กำลังรันด้วยคำสั่ง ในการดำเนินการนี้ ให้เปิดเทอร์มินัลที่สอง:

อย่างไรก็ตาม หากเราออกคำสั่ง เราจะไม่พบคอนเทนเนอร์ที่สร้างจากอิมเมจ mysql มาใช้ตัวเลือกกันเถอะ -NSซึ่งแสดงคอนเทนเนอร์ทั้งหมด ไม่ใช่แค่รันคอนเทนเนอร์:

เห็นได้ชัดว่าไม่ได้ระบุพารามิเตอร์ที่จำเป็นเมื่อเริ่มต้นคอนเทนเนอร์ สำหรับคำอธิบายของตัวแปรสภาพแวดล้อมที่จำเป็นในการรันคอนเทนเนอร์ โปรดดูที่อิมเมจ MySQL อย่างเป็นทางการบน Docker Hub ลองอีกครั้งโดยใช้ตัวเลือก -eซึ่งตั้งค่าตัวแปรสภาพแวดล้อมในคอนเทนเนอร์:

$ docker run --name mysql-test ↵ -e MYSQL_ROOT_PASSWORD = docker -d mysql

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

อันที่จริงหลังจากรันคำสั่งนี้ลงในคอนเทนเนอร์ mysql-testเพิ่มอีกหนึ่งกระบวนการ - ทุบตี... สามารถเห็นได้อย่างชัดเจนโดยใช้คำสั่ง pstree เอาต์พุตตัวย่อไปยังคำสั่ง นักเทียบท่า ผู้บริหาร:

ข้อมูลเพิ่มเติมในหัวข้อ การเชื่อมต่อและกำหนดค่า iSCSI บน Windows Server Sun ตรงข้ามกับ IP Storage การสร้างภาพนักเทียบท่า ทำความเข้าใจ Docker ส่วนประกอบหลักของ Docker การเขียน VBA Macros ใน LibreOffice ทำความสะอาด ubuntu จากที่ไม่จำเป็นทั้งหมด ทำความสะอาด linux mint จากขยะผ่านเทอร์มินัล ข้อความเลื่อนย้อนกลับในคอนโซล Linux การสร้างแผนภูมิใน OpenOffice © ลิขสิทธิ์ 2017, https://qzoreteam.ru