S21_Linux_SimpleDocker

นักเทียบท่าเรียบง่าย

รู้เบื้องต้นเกี่ยวกับนักเทียบท่า การพัฒนาอิมเมจนักเทียบท่าอย่างง่ายสำหรับเซิร์ฟเวอร์ของคุณเอง

งานเวอร์ชันรัสเซียสามารถพบได้ในที่เก็บ

สารบัญ

1. บทที่ 1
2. บทที่ 2
   2.1. nginx
   2.2. นักเทียบท่า
   2.3. ท่าเทียบเรือ
3. บทที่ III
   3.1. Docker สำเร็จรูป
   3.2. การดำเนินงานด้วยคอนเทนเนอร์
   3.3. เว็บเซิร์ฟเวอร์ขนาดเล็ก
   3.4. นักเทียบท่าของคุณเอง
   3.5. ท่าเทียบเรือ
   3.6. นักเทียบท่าพื้นฐานเขียน

บทที่ 1

Planet Earth ที่ไหนสักแห่งกลางทะเลวันนี้

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

จากหน้าต่างห้องโดยสารของคุณคุณได้ยินเสียงคลื่นเรือโยกอย่างสงบสุขและคุณจำนวนิยายที่คุณชื่นชอบเกี่ยวกับทะเล - "Moby Dick" แม้ว่าพล็อตจะยังห่างไกลจากความตรงไปตรงมา แต่มีการพูดนอกเรื่องโคลงสั้น ๆ และดนตรีปรัชญามากมายคุณก็เหมือนกับคนอื่น ๆ ที่เกี่ยวข้องกับหนังสือเล่มนี้เป็นหลักกับ Moby Dick เอง - White Whale

"อืม ... White Whale ... " นี่คือที่ที่คุณจำได้ว่าในระหว่างการเดินทางที่ยาวนานคุณต้องการทำงานบนท่าเรือ

บทที่ 2

nginx

NGINX (ออกเสียงว่า "Engine-X") เป็นเซิร์ฟเวอร์พร็อกซีย้อนกลับโอเพนซอร์ซสำหรับ HTTP, HTTPS ฯลฯ NGINX ยังใช้เป็นตัวโหลดบาลานซ์เว็บเซิร์ฟเวอร์และการแคช HTTP โครงการ NGINX มุ่งเน้นไปที่ความเท่าเทียมสูงประสิทธิภาพสูงและการใช้หน่วยความจำต่ำ

Nginx มีกระบวนการหลักหนึ่งกระบวนการและกระบวนการของผู้ปฏิบัติงานหลายอย่าง ภารกิจหลักของกระบวนการหลักคือการอ่านและตรวจสอบการกำหนดค่าและจัดการกระบวนการของผู้ปฏิบัติงาน กระบวนการของคนงานดำเนินการประมวลผลจริงของคำขอ

วิธีการทำงานของ Nginx และโมดูลของมันถูกกำหนดไว้ในไฟล์การกำหนดค่า โดยค่าเริ่มต้นไฟล์การกำหนดค่าเรียกว่า nginx.conf

นักเทียบท่า

คอนเทนเนอร์เป็น "ไฟล์ที่เรียกใช้งานได้" ใหม่ซึ่งรวมถึงความต้องการของผลิตภัณฑ์ทั้งหมด

ข้อได้เปรียบหลักของ containerisation คือการแยกการพึ่งพาและจุดเริ่มต้นซอฟต์แวร์ง่าย ๆ

เงื่อนไขพื้นฐาน:

• Docker Image - "แพ็คเกจ" สำหรับแอปพลิเคชันและการพึ่งพา (รวมถึงระบบ)
• คอนเทนเนอร์ - อินสแตนซ์ของภาพคือภาพ 'ยังมีชีวิตอยู่'

Docker เป็นแพลตฟอร์มที่ออกแบบมาเพื่อพัฒนาปรับใช้และเรียกใช้แอปพลิเคชันในคอนเทนเนอร์ Docker เป็นเครื่องมือ containerisation มาตรฐาน 'de-facto' ในอุตสาหกรรม แต่ไม่ใช่เทคโนโลยีแรกหรือครั้งสุดท้ายในเทคโนโลยีคอนเทนเนอร์

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

ภาพนักเทียบท่าประกอบด้วยเลเยอร์ แต่ละเลเยอร์อธิบายการเปลี่ยนแปลงบางอย่างที่จะดำเนินการกับข้อมูลในคอนเทนเนอร์ที่กำลังทำงาน โครงสร้างของการเชื่อมโยงระหว่างเลเยอร์เป็นลำดับชั้น มีเลเยอร์พื้นฐานที่ชั้นอื่น ๆ "ซ้อนทับ" DockerFile ใช้เพื่อสร้างภาพ แต่ละคำสั่งในนั้นสร้างเลเยอร์ใหม่

ท่าเทียบเรือ

Dockle เป็นเครื่องมือตรวจสอบความปลอดภัยของภาพคอนเทนเนอร์ที่สามารถใช้เพื่อค้นหาช่องโหว่

คุณสมบัติที่สำคัญและประโยชน์ของ Dockle :

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

นักเทียบท่า

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

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

บทที่ III

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

เป็นผลมาจากงานที่สามคุณควรจัดเตรียมไฟล์ต้นฉบับสำหรับเรียกใช้เว็บเซิร์ฟเวอร์

อันเป็นผลมาจากงานที่สี่และห้าคุณควรให้ Dockerfiles

อันเป็นผลมาจากภารกิจที่หกคุณควรจัดเตรียมไฟล์ Docker-compose.yml และ dockerfiles ที่จำเป็นในการเรียกใช้ (หากไม่ได้ให้ไว้ก่อนหน้านี้)

• รายงานที่มีส่วนขยาย. MD จะต้องอัปโหลดไปยังที่เก็บในโฟลเดอร์ SRC
• ทุกส่วนของงานควรได้รับการเน้นในรายงานเป็นส่วนหัวระดับ 2;
• ภายในส่วนหนึ่งของงานทุกอย่างที่เพิ่มลงในรายงานจะต้องอยู่ในรูปแบบของรายการ
• ภาพหน้าจอแต่ละภาพในรายงานจะต้องมีคำบรรยายสั้น ๆ (มีอะไรอยู่ในภาพหน้าจอ);
• ภาพหน้าจอทั้งหมดจะต้องถูกตัดเพื่อให้มีเพียงส่วนที่เกี่ยวข้องของหน้าจอเท่านั้น
• มันได้รับอนุญาตให้มีหลายจุดงานที่แสดงในภาพหน้าจอเดียว แต่พวกเขาทั้งหมดจะต้องอธิบายไว้ในคำบรรยายภาพ;
• ไฟล์ต้นฉบับสำหรับเรียกใช้เว็บเซิร์ฟเวอร์จากงานที่สามควรอัปโหลดไปยังที่เก็บในโฟลเดอร์ SRC/Server;
• Dockerfiles จากงานที่สี่และห้าควรอัปโหลดไปยังที่เก็บในโฟลเดอร์ SRC;
• Docker-compose.yml จากงานที่หกควรอัปโหลดไปยังที่เก็บในโฟลเดอร์ SRC;
• เตรียมพร้อมที่จะแสดงให้เห็นถึงงานของคุณหากจำเป็น

ตอนที่ 1. Docker สำเร็จรูป

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

== งาน ==

ถ่ายภาพ Docker อย่างเป็นทางการจาก Nginx และดาวน์โหลดโดยใช้ docker pull

ตรวจสอบภาพนักเทียบท่าด้วย docker images

เรียกใช้อิมเมจนักเทียบท่าด้วย docker run -d [image_id|repository]

ตรวจสอบว่าภาพกำลังทำงานด้วย docker ps

ดูข้อมูลคอนเทนเนอร์ด้วย docker inspect [container_id|container_name]

จากคำสั่งเอาต์พุตกำหนดและเขียนในรายงานขนาดคอนเทนเนอร์รายการของพอร์ตที่แมปและ IP คอนเทนเนอร์

หยุดภาพ Docker ด้วย docker stop [container_id|container_name]

ตรวจสอบว่าภาพหยุดด้วย docker ps

เรียกใช้ Docker ด้วยพอร์ต 80 และ 443 ในคอนเทนเนอร์ซึ่งแมปกับพอร์ตเดียวกันบนเครื่องท้องถิ่นพร้อมคำสั่ง Run

ตรวจสอบว่าหน้าเริ่มต้น Nginx มีอยู่ในเบราว์เซอร์ที่ LocalHost: 80

รีสตาร์ทคอนเทนเนอร์ Docker ด้วย docker restart [container_id|container_name]

ตรวจสอบในแบบที่คอนเทนเนอร์กำลังทำงานอยู่

• เพิ่มภาพหน้าจอต่อไปนี้ในรายงาน:
  • การโทรและผลลัพธ์ของคำสั่งทั้งหมดที่ใช้ในส่วนนี้ของงาน
  • หน้าเริ่มต้น Nginx ที่ LocalHost: 80 (ต้องแสดงที่อยู่)

หมายเหตุ: อย่าอัปโหลดไฟล์หนัก (> 10 MB) ไปยัง GIT

ส่วนที่ 2 การดำเนินการกับคอนเทนเนอร์

อิมเมจและคอนเทนเนอร์ Docker พร้อมแล้ว ตอนนี้เราสามารถดูการกำหนดค่า NGINX และสถานะหน้าจอแสดงผล

== งาน ==

อ่านไฟล์กำหนดค่า nginx.conf ภายในคอนเทนเนอร์ Docker ด้วยคำสั่ง EXEC

สร้างไฟล์ nginx.conf บนเครื่องท้องถิ่น

กำหนดค่าบนพา ธ /สถานะ เพื่อส่งคืนหน้าสถานะเซิร์ฟเวอร์ Nginx

คัดลอกไฟล์ nginx.conf ที่สร้างขึ้นภายในอิมเมจ Docker โดยใช้คำสั่ง docker cp

รีสตาร์ท nginx ภายในอิมเมจนักเทียบท่าด้วย EXEC

ตรวจสอบว่า localhost: 80/สถานะ ส่งคืนหน้าสถานะเซิร์ฟเวอร์ Nginx

ส่งออกคอนเทนเนอร์ไปยังไฟล์ container.tar พร้อมคำสั่ง ส่งออก

หยุดคอนเทนเนอร์

ลบภาพด้วย docker rmi [image_id|repository] โดยไม่ต้องถอดคอนเทนเนอร์ออกก่อน

ลบคอนเทนเนอร์หยุด

นำเข้าคอนเทนเนอร์กลับมาโดยใช้คำสั่ง นำเข้า

เรียกใช้ภาชนะที่นำเข้า

ตรวจสอบว่า localhost: 80/สถานะ ส่งคืนหน้าสถานะเซิร์ฟเวอร์ Nginx

• เพิ่มภาพหน้าจอต่อไปนี้ในรายงาน:
  • การโทรและผลลัพธ์ของคำสั่งทั้งหมดที่ใช้ในส่วนนี้ของงาน
  • เนื้อหาของไฟล์ nginx.conf ที่สร้างขึ้น;
  • หน้าสถานะเซิร์ฟเวอร์ Nginx ที่ LocalHost: 80/สถานะ

ตอนที่ 3. เว็บเซิร์ฟเวอร์มินิ

ถึงเวลาหยุดพักจากนักเทียบท่าเล็กน้อยเพื่อเตรียมพร้อมสำหรับขั้นตอนสุดท้าย ถึงเวลาเขียนเซิร์ฟเวอร์ของคุณเอง

== งาน ==

เขียน Mini Server ใน C และ FastCGI ที่จะส่งคืนหน้าง่าย ๆ กล่าวว่า Hello World! -

เรียกใช้ Mini Server ที่เป็นลายลักษณ์อักษรผ่าน Spawn-FCGI บนพอร์ต 8080

เขียน nginx.conf ของคุณเองที่จะส่งคำขอทั้งหมดจากพอร์ต 81 ถึง 127.0.0.1:8080

ตรวจสอบเบราว์เซอร์นั้นใน LocalHost: 81 ส่งคืนหน้าเว็บที่คุณเขียน

ใส่ไฟล์ nginx.conf ภายใต้ ./nginx/nginx.conf (คุณจะต้องใช้ในภายหลัง)

ตอนที่ 4. นักเทียบท่าของคุณเอง

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

== งาน ==

เมื่อเขียนอิมเมจนักเทียบท่าหลีกเลี่ยงคำแนะนำการเรียกใช้หลายครั้ง

เขียนภาพนักเทียบท่าของคุณเองว่า:

1) สร้างแหล่ง Mini Server บน FastCGI จาก [ตอนที่ 3] (#ตอนที่ 3 มิติ-เว็บเซิร์ฟเวอร์);

2) เรียกใช้บนพอร์ต 8080;

3) สำเนาภายในภาพที่เขียน ./nginx/nginx.conf ;

4) รัน nginx

Nginx สามารถติดตั้งภายใน Docker เองหรือคุณสามารถใช้อิมเมจสำเร็จรูปกับ Nginx เป็นฐาน

สร้างภาพนักเทียบท่าที่เป็นลายลักษณ์อักษรด้วย docker build โดยระบุชื่อและแท็ก

ตรวจสอบด้วย docker images ว่าทุกอย่างถูกสร้างขึ้นอย่างถูกต้อง

เรียกใช้อิมเมจนักเทียบท่าที่สร้างขึ้นโดยการแมปพอร์ต 81 ถึง 80 บนเครื่องท้องถิ่นและการแมปโฟลเดอร์ ./ nginx ภายในคอนเทนเนอร์ไปยังที่อยู่ที่ไฟล์การกำหนดค่า NGINX อยู่ (ดูส่วนที่ 2)

ตรวจสอบว่าหน้าของ Mini Server ที่เป็นลายลักษณ์อักษรนั้นมีอยู่ใน LocalHost: 80

เพิ่มพร็อกซ์ของ /หน้าสถานะ ใน ./nginx/nginx.conf เพื่อส่งคืนสถานะเซิร์ฟเวอร์ nginx

รีสตาร์ทรูปภาพ Docker

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

ตรวจสอบว่า localhost: 80/สถานะ ตอนนี้ส่งคืนหน้าด้วยสถานะ nginx

ตอนที่ 5. Dockle

เมื่อคุณเขียนภาพแล้วก็ไม่ควรตรวจสอบความปลอดภัย

== งาน ==

ตรวจสอบภาพจากงานก่อนหน้าด้วย dockle [image_id|repository]

แก้ไขภาพเพื่อให้ไม่มีข้อผิดพลาดหรือคำเตือนเมื่อตรวจสอบกับ Dockle

ตอนที่ 6. นักเทียบท่าพื้นฐานเขียน

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

== งาน ==

เขียนไฟล์ Docker-compose.yml โดยใช้:

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

2) เริ่มคอนเทนเนอร์ Docker ด้วย Nginx ซึ่งจะส่งคำขอทั้งหมดจากพอร์ต 8080 ถึงพอร์ต 81 ของคอนเทนเนอร์แรก

แผนที่พอร์ต 8080 ของคอนเทนเนอร์ที่สองไปยังพอร์ต 80 ของเครื่องท้องถิ่น

หยุดภาชนะที่ใช้งานทั้งหมด

สร้างและเรียกใช้โครงการด้วยคำสั่ง docker-compose build และ docker-compose up

ตรวจสอบว่าเบราว์เซอร์ส่งคืนหน้าเว็บที่คุณเขียนบน LocalHost: 80 เหมือนก่อน

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