‫เอาล่ะในการบรรยายครั้งนี้เราจะพูดถึงเลเยอร์ภาพ
‫นี่เป็นแนวคิดพื้นฐานของวิธีการทำงานของนักเทียบท่า
‫มันใช้สิ่งที่เรียกว่าระบบไฟล์รวมเพื่อแสดงชุดของการเปลี่ยนแปลงระบบไฟล์เป็นระบบไฟล์จริง
‫เราจะดำดิ่งลงไปในประวัติศาสตร์และตรวจสอบคำสั่งและดูว่าเราจะใช้มันเพื่อทำความเข้าใจว่าภาพนั้นทำมาจากอะไร
‫เราจะเรียนรู้เล็กน้อยเกี่ยวกับการคัดลอกแนวคิดการเขียนว่าคอนเทนเนอร์ทำงานอย่างไรเป็นเลเยอร์เพิ่มเติมที่ด้านบนของภาพ
‫เลเยอร์รูปภาพหมายถึงอะไร
‫จริงๆแล้วมันโปร่งใสสำหรับคุณโดยเฉพาะเมื่อคุณใช้
‫Docker แต่เมื่อคุณเริ่มขุดลงในคำสั่งบางอย่างเช่นคำสั่งประวัติการตรวจสอบและการคอมมิทคุณจะเริ่มรู้สึกว่าภาพไม่ใช่ข้อมูลขนาดใหญ่ มาและไปในก้อนใหญ่หนึ่ง
‫ขวา?
‫หากคุณสังเกตเห็นว่าเมื่อเราดึงนักเทียบท่าออกมาจริง ๆ บางครั้งคุณอาจเห็นคำที่ระบุว่ามีบางสิ่งที่คุณมีอยู่แล้วเช่นที่คุณแคชบางส่วนของมันไว้แล้ว
‫แนวคิดระบบไฟล์รวมของการทำเลเยอร์เกี่ยวกับการเปลี่ยนแปลง
‫หากเราสามารถดูสิ่งที่เรามีใน Docker ได้อย่างรวดเร็ว ในภาพนักเทียบท่าจริง ...
‫ไม่นานมานี้เราได้เล่นกับแท็กที่มี Nginx ขวา?
‫เราจำได้ว่ารหัสภาพ Nginx เหมือนกันและเรามีแท็กที่แตกต่างกันสำหรับชื่อภาพเดียวกัน
‫ลองทำประวัตินักเทียบท่าอย่างรวดเร็วกับ nginx ล่าสุด
‫ฉันกำลังดูอะไรที่นี่?
‫นี่ไม่ใช่รายการของสิ่งต่าง ๆ ที่เกิดขึ้นจริงในคอนเทนเนอร์เนื่องจากเป็นรูปภาพ
‫นี่คือประวัติของเลเยอร์ภาพ
‫ทุกภาพเริ่มต้นจากจุดเริ่มต้นที่มีเลเยอร์ว่างเปล่าที่รู้จักกันเป็นรอยขีดข่วน
‫จากนั้นทุกชุดของการเปลี่ยนแปลงที่เกิดขึ้นหลังจากนั้นในระบบไฟล์ในภาพจะเป็นอีกชั้นหนึ่ง
‫คุณอาจมีหนึ่งเลเยอร์คุณอาจมีหลายสิบเลเยอร์และบางเลเยอร์อาจไม่มีการเปลี่ยนแปลงในแง่ของขนาดไฟล์
‫คุณจะสังเกตเห็นว่าที่นี่เรามีการเปลี่ยนแปลงจริง ๆ ซึ่งเป็นเพียงการเปลี่ยนแปลงข้อมูลเมตาเกี่ยวกับคำสั่งที่เราจะเรียกใช้
‫เราจะพูดถึงเรื่องนี้เล็กน้อยเมื่อเราไปที่ Dockerfile
‫แต่สำหรับตอนนี้คุณสามารถเห็นได้ว่าอันนี้เพิ่มไฟล์จำนวนมากนั่นคือ 123MB
‫จากนั้นเราทำการเปลี่ยนแปลงที่นี่และการเปลี่ยนแปลงที่นี่และฉันรู้เพราะ Dockerfiles ว่านี่เป็นเพียงข้อมูลเมตาของ
‫Dockerfile
‫เมื่อคุณขึ้นไปเรามีการเปลี่ยนแปลงข้อมูลเพิ่มเติม
‫คุณจะเห็นว่าจริง ๆ แล้วมันแตกต่างกันมากในรูปภาพอื่น
‫ดังนั้นถ้าเราไปที่ mysql ประวัตินักเทียบท่ามันมีเลเยอร์ภาพที่แตกต่างอย่างสิ้นเชิง
‫ขอผมวาดนี่หน่อยสำหรับคุณและอาจช่วยได้
‫เมื่อเราเริ่มรูปภาพเมื่อเราสร้างภาพใหม่เราจะเริ่มต้นด้วยชั้นหนึ่ง
‫ทุกชั้นได้รับ SHA ที่เป็นเอกลักษณ์ของตัวเองที่ช่วยให้ระบบระบุได้ว่าชั้นนั้นเหมือนกับชั้นอื่นหรือไม่
‫สมมติว่าในตอนต้นของคุณคุณอาจมี Ubuntu ที่ด้านล่างสุด
‫นั่นคือเลเยอร์แรกในรูปภาพของคุณ
‫จากนั้นคุณสร้างไฟล์ Dockerfile ซึ่งจะเพิ่มไฟล์บางไฟล์และเป็นเลเยอร์อื่นที่อยู่ด้านบนของภาพนั้น
‫บางทีเราอาจใช้ Apt เพื่อสิ่งนั้น
‫จากนั้นใน Dockerfile ของคุณคุณทำการเปลี่ยนแปลงตัวแปรสภาพแวดล้อม นั่นคือรูปภาพของคุณ
‫ตกลง?
‫คุณอาจมีภาพที่แตกต่างจากเดเบียน: เจสซีและจากนั้นคุณอาจใช้ Apt เพื่อติดตั้งบางสิ่งสมมติว่า
‫MySQL
‫คุณอาจคัดลอกไฟล์บางไฟล์ไปคุณอาจเปิดพอร์ต
‫ดังนั้นการเปลี่ยนแปลงเหล่านี้แต่ละครั้งที่คุณมักจะทำใน Dockerfile แต่คุณสามารถทำได้ด้วยคำสั่ง commit
‫docker ที่เราจะเช็คเอาท์ในหนึ่งนาที
‫นี่เป็นอีกภาพหนึ่งและรวมเข้าด้วยกัน
‫จะเกิดอะไรขึ้นถ้าฉันมีภาพอื่นที่ใช้เจสซี่รุ่นเดียวกันด้วย
‫อิมเมจนั้นสามารถเปลี่ยนแปลงได้เองบนเลเยอร์เดียวกันกับที่ฉันมีในแคช
‫นี่คือที่แนวคิดพื้นฐานของแคชเลเยอร์ภาพช่วยเราประหยัดทั้งเวลาและพื้นที่ เนื่องจากเราไม่จำเป็นต้องดาวน์โหลดเลเยอร์ที่เรามีอยู่แล้วและจำไว้ว่ามันใช้
‫SHA ที่ไม่ซ้ำกันสำหรับแต่ละเลเยอร์ดังนั้นจึงรับประกันได้ว่าเลเยอร์ที่แน่นอนนั้นต้องการ
‫มันรู้วิธีจับคู่ระหว่าง Docker Hub กับแคชในเครื่องของเรา
‫เมื่อเราทำการเปลี่ยนแปลงภาพของเราพวกมันจะสร้างเลเยอร์มากขึ้น
‫หากเราตัดสินใจว่าเราต้องการให้มีภาพเดียวกันเป็นภาพฐานสำหรับเลเยอร์มากขึ้นแสดงว่าเป็นเพียงการจัดเก็บหนึ่งสำเนาของแต่ละเลเยอร์เท่านั้น
‫ในระบบนี้จริงๆหนึ่งในประโยชน์ที่ใหญ่ที่สุดคือเราไม่เคยจัดเก็บข้อมูลภาพเดียวกันมากกว่าหนึ่งครั้งในระบบไฟล์ของเรา
‫นอกจากนี้ยังหมายความว่าเมื่อเราอัพโหลดและดาวน์โหลดเราไม่จำเป็นต้องอัพโหลดและดาวน์โหลดเลเยอร์เดียวกันกับที่เรามีอยู่แล้วในอีกด้านหนึ่ง
‫ถ้าคุณต้องมีภาพของตัวเองและมันเป็นธรรมเนียมที่คุณสร้างขึ้นเองจากนั้นคุณก็เพิ่มเข้าไปสมมติว่าเซิร์ฟเวอร์ Apache ที่อยู่ด้านบนนั้นเป็นเลเยอร์อื่นใน Dockerfile
‫ของคุณจากนั้นคุณจะต้องเปิดพอร์ต 80 จากนั้นในตอนท้ายคุณบอกให้คัดลอกในซอร์สโค้ด แต่จริง ๆ
‫แล้วคุณมี Dockerfiles ที่แตกต่างกันสองแห่งสำหรับสองเว็บไซต์ที่ต่างกันและทุกบรรทัดใน
‫Dockerfiles นั้นเหมือนกันยกเว้นเพียงเล็กน้อยสุดท้ายที่คุณคัดลอกเว็บไซต์ ในภาพและจากนั้นเว็บไซต์ B
‫คุณจะต้องจบด้วยภาพสองภาพ เราจะแสดงให้เห็นว่าภายในหนึ่งนาที
‫สิ่งนี้ประกอบขึ้นเป็นภาพเดียวและสิ่งนี้ทำให้เป็นภาพเดียว แต่ไฟล์เดียวที่ถูกจัดเก็บจริงคือภาพนี้หนึ่งภาพนี้เลเยอร์นี้แล้วเลเยอร์เล็ก ๆ
‫นี้แล้วเลเยอร์นี้เล็ก ๆ
‫ดังนั้นเราจึงไม่เคยจัดเก็บเลเยอร์ภาพทั้งหมดซ้อนกันมากกว่าหนึ่งครั้งถ้าเป็นเลเยอร์เดียวกันจริงๆ
‫มันทำงานอย่างไรกับตู้คอนเทนเนอร์?
‫หากคุณมีภาพของคุณสมมติว่าเรามีภาพ Apache ของเราและเราตัดสินใจที่จะใช้ภาชนะออกจากมันทั้งหมดนักเทียบท่าทำมันคือการสร้างเลเยอร์อ่าน /
‫เขียนใหม่สำหรับภาชนะที่อยู่ด้านบนของภาพ Apache นั้น
‫เมื่อเราอ่านระบบไฟล์และสิ่งต่าง ๆ เหล่านี้ภาชนะและรูปภาพทั้งหมดดูเหมือนกับระบบไฟล์ปกติ แต่ภายใต้ไดรเวอร์อุปกรณ์เก็บข้อมูลที่ Docker
‫ใช้จริง ๆ แล้วก็ฝังลึกเหมือนกองแพนเค้ก
‫ด้านบนของกันและกัน
‫ดังนั้นถ้าฉันวิ่งสองตู้คอนเทนเนอร์ในเวลาเดียวกันจากอิมเมจ Apache เดียวกันคอนเทนเนอร์ 1
‫และคอนเทนเนอร์
‫2 จะแสดงเฉพาะในแง่ของพื้นที่ไฟล์พวกเขาจะแยกความแตกต่างระหว่างสิ่งที่เกิดขึ้นกับคอนเทนเนอร์สดที่ทำงานอยู่และสิ่งที่ เกิดขึ้นในอิมเมจพื้นฐานซึ่งอ่านได้อย่างเดียว
‫เมื่อคุณกำลังใช้งานคอนเทนเนอร์และคุณกำลังเปลี่ยนไฟล์ที่กำลังจะผ่านรูปภาพสมมติว่าฉันเริ่มคอนเทนเนอร์ 3
‫และจริง ๆ แล้วฉันเข้าไปข้างในและเปลี่ยนไฟล์ที่อยู่ในรูปภาพนี้ในคอนเทนเนอร์ที่กำลังทำงาน ...
‫สิ่งนี้เรียกว่า copy-on-write
‫สิ่งที่ทำคือระบบไฟล์จะนำไฟล์นั้นออกจากภาพและคัดลอกลงในส่วนต่าง ...
‫ขึ้นที่นี่ ... และเก็บสำเนาของไฟล์นั้นในเลเยอร์คอนเทนเนอร์
‫ดังนั้นตอนนี้ที่เก็บเป็นจริงเพียงแค่กระบวนการทำงานและไฟล์ที่แตกต่างจากที่อยู่ในรูปภาพ Apache
‫หากเรากลับไปที่รายการรูปภาพของเราและเราดูคำสั่งเหล่านี้อีกครั้งและเราดูที่ด้านล่างและดูว่าวันที่แตกต่างกันอย่างไร
‫เราเห็นจริง ๆ
‫ว่าภาพนี้มีการเปลี่ยนแปลงใน Docker Hub และได้รับการอัปเดตเมื่อเวลาผ่านไปซึ่งการเปลี่ยนแปลงเหล่านี้ไม่ได้เปลี่ยนแปลงที่ชั้นล่างสุดในสี่สัปดาห์จากนั้นการเปลี่ยนแปลงล่าสุดได้เกิดขึ้นในสองสัปดาห์ที่ผ่านมา
‫โอ้โดยวิธีการไม่ต้องกังวลกับส่วนที่ขาดหายไป
‫นั่นเป็นเพียงการเรียกชื่อผิดภายในอินเทอร์เฟซนักเทียบท่า
‫ไม่ได้หมายความว่ามีบางอย่างผิดปกติ ความหมายก็คือจริงๆแล้วภาพ mysql
‫นี่ตรงนี้คือรหัสภาพ
‫เลเยอร์อื่น ๆ ในภาพไม่ใช่ภาพของตัวเอง
‫พวกมันเป็นเพียงเลเยอร์ภายในภาพนี้และดังนั้นพวกเขาจึงไม่จำเป็นต้องได้รับรหัสภาพของตัวเองที่นั่น
‫โดยส่วนตัวฉันคิดว่ามันเป็นความเข้าใจผิดเล็กน้อยในอินเทอร์เฟซที่จะพูด แต่นั่นเป็นวิธีที่พวกเขาเขียน
‫ดังนั้นตอนนี้เราได้รับความรู้สึกของคำสั่งประวัติศาสตร์เพื่อแสดงให้เราเห็นสิ่งที่ภาพอาจจะทำจากให้ใช้คำสั่งตรวจสอบ
‫สิ่งนี้คือสิ่งนี้ทำให้เรามีรายละเอียดทั้งหมดเกี่ยวกับภาพ
‫นี่เป็นข้อมูลเมตา จำได้ไหมว่าเมื่อเราพูดถึงภาพที่ถูกสร้างขึ้นจากสองส่วนไบนารีและการพึ่งพาของมันแล้วเมตาดาต้าเกี่ยวกับภาพนั้น?
‫การตรวจสอบจะช่วยให้คุณคืนข้อมูลเมตา
‫นอกเหนือจากข้อมูลพื้นฐานเช่นรหัสรูปภาพและแท็กแล้วคุณจะได้รับรายละเอียดทุกอย่างเกี่ยวกับภาพที่คาดว่าจะทำงาน
‫มีตัวเลือกให้เปิดเผยสองพอร์ตเหล่านี้ภายในรูปภาพเพื่อให้คุณทราบเมื่อคุณต้องการเริ่มต้นพอร์ตใดที่คุณต้องเปิดขึ้นภายในโฮสต์ Docker
‫ของคุณหากคุณต้องการให้ยอมรับการเชื่อมต่อ
‫คุณจะเห็นได้ว่าตัวแปรสภาพแวดล้อมถูกส่งผ่านรวมถึงเวอร์ชันของ Nginx ที่มันทำงานอยู่และพา
‫ธ คุณสามารถเห็นคำสั่งที่มันจะทำงานเมื่อคุณเริ่มต้นภาพโดยค่าเริ่มต้น
‫อีกครั้งสิ่งต่าง ๆ เหล่านี้สามารถเปลี่ยนแปลงได้จริงอย่างที่เราเคยทำก่อนหน้านี้ด้วยคำสั่งเรียกใช้นักเทียบท่าคอนเทนเนอร์
‫แต่สิ่งเหล่านี้แสดงให้เราเห็นถึงค่าเริ่มต้นทั้งหมดและข้อมูลที่น่าสนใจอื่น ๆ
‫เช่นผู้เขียนและที่ด้านล่างนั่นคือสถาปัตยกรรมของ AMD64 ซึ่งเป็นสิ่งที่พีซีและ Mac ทั่วไปทุกเครื่องทำงานในปัจจุบัน
‫เราไม่มีเครื่อง 32 บิตมากเกินไปดังนั้นนี่เป็นเพียงสถาปัตยกรรม 64 บิตของ
‫Intel และได้รับการออกแบบให้ทำงานบน Linux OS
‫ตกลงรีวิวอย่างรวดเร็ว
‫ดังนั้นเราจึงได้เรียนรู้มากมายเกี่ยวกับภาพและวิธีการสร้างและเราพบว่าจริง ๆ
‫แล้วไม่ซับซ้อน จริงๆแล้วมันเป็นเพียงแค่ชุดของการเปลี่ยนแปลงในระบบไฟล์และข้อมูลเมตาเกี่ยวกับการเปลี่ยนแปลงเหล่านั้น
‫คุณได้เรียนรู้ว่าแต่ละเลเยอร์มีเอกลักษณ์เป็นของตนเองในฐานะ SHA
‫พวกเขาจะถูกเก็บไว้เพียงครั้งเดียวในแต่ละระบบดังนั้นในแต่ละ Docker daemon แต่ละชั้นจะแสดงเพียงครั้งเดียวในระบบไฟล์
‫นั่นทำให้เราประหยัดพื้นที่ได้มากรวมถึงเวลาในการถ่ายโอนภาพไปมาระหว่างการลงทะเบียนเช่น Docker Hub
‫และจริงๆแล้วเมื่อคุณเริ่มต้นคอนเทนเนอร์มันเป็นเพียงการเปลี่ยนแปลงชั้นเดียวที่ด้านบนของภาพที่มีอยู่
‫ดังนั้นปกติแล้วมันจะเล็กมาก
‫เราเรียนรู้เกี่ยวกับประวัติศาสตร์และตรวจสอบคำสั่งและวิธีที่พวกเขาสามารถสอนเราว่าเกิดอะไรขึ้นภายในภาพและวิธีการสร้าง