วิธีสร้างอิมเมจ Python Docker ที่มีประสิทธิภาพ

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

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

ทำความเข้าใจกระบวนการโดยตรวจสอบภาพประกอบเชิงปฏิบัติที่สาธิตการใช้งานแอปพลิเคชันเครื่องคิดเลข Python ภายในสภาพแวดล้อมแบบคอนเทนเนอร์

เริ่มต้นด้วยอิมเมจฐานขั้นต่ำ

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

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

การเลือก “python:3.11-slim-bookworm” เป็นภาษาการเขียนโปรแกรมสำหรับแอปพลิเคชันเครื่องคิดเลข นำไปสู่ภาพที่ได้รับการปรับปรุงให้เหมาะสมซึ่งใช้ทรัพยากรน้อยลง ส่งผลให้การใช้ทรัพยากรลดลงในระหว่างการปรับใช้และดาวน์โหลดแอปพลิเคชันได้เร็วขึ้น

 # Starting With a Minimal Base Image
FROM python:3.11-slim-bookworm AS builder 

คุณมีทางเลือกในการใช้การกระจาย Alpine Linux ที่กะทัดรัดยิ่งขึ้นโดยเลือก “python:3.11-alpine” อย่างไรก็ตาม สิ่งสำคัญคือต้องทราบว่าอิมเมจนี้ละเว้นการรวมล่าม Python ตัวจัดการแพ็คเกจ และไลบรารี Python ที่จำเป็น

เรียกใช้แอปพลิเคชันในฐานะผู้ใช้ที่ไม่ใช่รูท

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

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

 # Set non-root user for security
RUN adduser calculator --system

# Add the user to the calculator group
RUN addgroup calculator && adduser calculator calculator

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

การคัดลอกไฟล์ที่จำเป็นและสร้างสภาพแวดล้อมเสมือนจริง

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

แน่นอน! นี่คือความพยายามของฉันในการถอดความคำแนะนำในลักษณะที่ซับซ้อนยิ่งขึ้น: หากต้องการตั้งค่าแอปพลิเคชันเครื่องคิดเลขภายในคอนเทนเนอร์ Docker โปรดทำตามขั้นตอนเหล่านี้อย่างระมัดระวัง:1. ขั้นแรก ถ่ายโอนไฟล์สำคัญทั้งหมดจากเครื่องของคุณไปยังโฟลเดอร์ที่กำหนดบนเซิร์ฟเวอร์ซึ่งมีอิมเมจ Docker อยู่ กระบวนการนี้เกี่ยวข้องกับการคัดลอกข้อมูลที่จำเป็นเพื่อช่วยให้การทำงานของซอฟต์แวร์ราบรื่น2. จากนั้น ใช้โมดูล venv ที่มีประสิทธิภาพซึ่งติดตั้งไว้ล่วงหน้าด้วย Python เพื่อสร้างสภาพแวดล้อมเสมือนจริงที่แยกออกมาภายในคอนเทนเนอร์ การทำเช่นนี้ทำให้เรามั่นใจได้ว่าแอปพลิเคชันทำงานได้อย่างราบรื่นโดยไม่มีการรบกวนหรือขัดแย้งกับแพ็คเกจที่ติดตั้งอื่น ๆ วัตถุประสงค์ของขั้นตอนนี้คือเพื่อให้มีสภาพแวดล้อมที่สมบูรณ์และปลอดภัยเพื่อให้โปรแกรมเครื่องคิดเลขทำงานได้อย่างเหมาะสมที่สุด

 # Set working directory and copy necessary files
WORKDIR /app
COPY app.py .
COPY requirements.txt .
COPY config.json ./
# Copy config.json from the local directory

# Create a virtual environment and install dependencies
RUN python -m venv /venv
ENV PATH="/venv/bin:$PATH"
RUN /venv/bin/pip install --upgrade pip --no-cache-dir --requirement requirements.txt 

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

การลดขนาดเลเยอร์ให้เหลือน้อยที่สุดเพื่อประสิทธิภาพ

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

 # Minimizing Layers for Efficiency
# Combine commands to reduce the number of layers
RUN echo "Build process goes here" && \
   /venv/bin/python -m compileall . && \
   rm -rf __pycache__ 

ด้วยการใช้คำแนะนำข้างต้น เราสามารถลดการสร้างเลเยอร์กลางตลอดขั้นตอนการสร้างภาพได้อย่างมีประสิทธิภาพ

การรักษาความปลอดภัยการจัดการการกำหนดค่า

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

 # Securing Configuration Handling
RUN mkdir /config && chown calculator:calculator /config

หลังจากวางไฟล์"config.json"ที่ซ้ำกันในโฟลเดอร์นี้โดยยังคงแยกไฟล์ออกจากซอร์สโค้ดของแอปพลิเคชัน

 # Copy the config.json file into the container
RUN cp config.json /config/config.json
ENV CONFIG_PATH=/config/config.json 

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

การใช้งานสร้างแบบหลายขั้นตอน

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

 # Leveraging Multi-Stage Builds
FROM python:3.11-slim-bookworm

COPY --from=builder /etc/passwd /etc/passwd
COPY --from=builder /etc/group /etc/group
COPY --from=builder /venv /venv
COPY --from=builder /config /config
COPY --from=builder /app /app
# Copy the application code

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

เพิ่มความปลอดภัยด้วยการสแกนรูปภาพ

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

 # Install Trivy for Debian/Ubuntu
RUN apt-get update && \
   apt-get install -y wget apt-transport-https gnupg lsb-release && \
   wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | apt-key add - && \
   echo "deb https://aquasecurity.github.io/trivy-repo/deb bookworm main" \
   | tee -a /etc/apt/sources.list.d/trivy.list && \
   apt-get update && \
   apt-get install -y trivy 

การรวมความสามารถในการสแกนช่องโหว่ของ Trivy ไว้ในอิมเมจ Docker มีความสำคัญอย่างยิ่งเนื่องจากการพึ่งพาฐานข้อมูล Common Vulnerabilities and Exposures (CVE) ที่ได้รับการยอมรับอย่างกว้างขวาง ฐานข้อมูล CVE ให้การอัปเดตทันเวลาเกี่ยวกับช่องโหว่ที่ระบุ ช่วยให้สามารถรักษาความปลอดภัยของภาพได้อย่างต่อเนื่องโดยการนำแพตช์ล่าสุดไปใช้ ด้วยเหตุนี้ จึงช่วยลดความเสี่ยงที่อาจเกิดขึ้นที่เกี่ยวข้องกับการหาประโยชน์และการป้องกันการเข้าถึงโดยไม่ได้รับอนุญาตหรือการละเมิดข้อมูล

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

 docker run --rm `
 -v /var/run/docker.sock:/var/run/docker.sock `
 -v $HOME/Library/Caches:/root/.cache/ `
 aquasec/trivy:0.18.3 `
 <your image name> 

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

มีความจำเป็นที่จะต้องแก้ไขช่องโหว่ด้านความปลอดภัยโดยทันทีตามระดับความรุนแรง เนื่องจากยิ่งปัญหารุนแรงมากเท่าใดก็ยิ่งต้องแก้ไขได้เร็วยิ่งขึ้นเท่านั้น

เรียกใช้แอปพลิเคชันในฐานะผู้ใช้ที่ไม่ใช่รูท

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

 # Running Applications as Non-Root Users
WORKDIR /app
USER calculator

# Activate the virtual environment and run the application
CMD ["/bin/bash", "-c", "source /venv/bin/activate && python app.py"]

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

การจัดคอนเทนเนอร์แอปพลิเคชันที่ไม่ใช่ Python

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