Hur man skapar effektiva Python Docker Images
Docker är branschstandard för paketering och distribution av applikationer i containrar. Docker-bilder är den hörnsten som du kan bygga och köra dina applikationer på.
För att kunna utnyttja Dockers alla möjligheter är det viktigt att finjustera sina containeravbildningar med fokus på att optimera resursanvändningen, förbättra säkerhetsåtgärderna och förbättra den övergripande prestandan. På så sätt kan du underlätta sömlös drift av dina applikationer i Docker-miljön.
Få en förståelse för processen genom att granska en praktisk illustration som visar distributionen av en Python-kalkylatorapplikation i en containeriserad miljö.
Börja med en minimal basimage
Valet av en basimage kan ha en betydande inverkan på Docker-containerns prestanda, och det rekommenderas att börja med en minimal image som endast innehåller de grundläggande element som krävs för att köra den önskade applikationen.
Välj en image som har en pålitlig historia av att leverera säkerhetsuppdateringar och korrigeringar i rätt tid och som har en engagerad användarbas som stöds av omfattande dokumentation. Sådana funktioner är ovärderliga för att lösa eventuella tekniska problem eller söka vägledning under projektets utveckling.
Att välja “python:3.11-slim-bookworm” som programmeringsspråk för kalkylatorapplikationen leder till en optimerad bild som kräver färre resurser. Följaktligen resulterar detta i minskad resursförbrukning under installationen och snabbare nedladdningar av applikationen.
# Starting With a Minimal Base Image
FROM python:3.11-slim-bookworm AS builder
Du har möjlighet att använda en mer kompakt Alpine Linux-distribution genom att välja “python:3.11-alpine”. Det är dock viktigt att notera att just denna bild saknar en Python-tolk, en pakethanterare och viktiga Python-bibliotek.
Köra program som icke-rotanvändare
Att köra Docker-containrar med administrativa behörigheter, t.ex. de som rotanvändaren har, kan leda till allvarliga säkerhetsproblem om någon obehörig får tillgång till containern. I sådana scenarier kan angripare utnyttja eventuella befintliga sårbarheter i containerapplikationen eller dess beroenden för att höja sin privilegienivå. När detta har uppnåtts kan de utföra godtyckliga kommandon på det underliggande värdsystemet och därigenom äventyra dess integritet och sekretess. Det är viktigt för organisationer att implementera robusta säkerhetsåtgärder och bästa praxis när de distribuerar och hanterar Docker-containrar för att minska dessa potentiella hot.
Att köra applikationer med reducerade rättigheter, t.ex. under ett icke-root-användarkonto, kan vara en effektiv säkerhetsåtgärd för att minska potentiella risker som är förknippade med att ge fullständiga åtkomsträttigheter till kritiska systemresurser. Genom att implementera denna praxis isoleras applikationens processer från känsliga områden i operativsystemet, vilket begränsar omfattningen av eventuell skadlig aktivitet som kan uppstå inom ramen för applikationen. Detta tillvägagångssätt underlättar också bättre granskningsmöjligheter genom att möjliggöra mer detaljerad spårning av åtgärder som utförs av applikationen. Dessutom bidrar det till att upprätthålla integriteten i det underliggande systemet genom att förhindra obehöriga ändringar eller manipulering av viktiga inställningar.
# Set non-root user for security
RUN adduser calculator --system
# Add the user to the calculator group
RUN addgroup calculator && adduser calculator calculator
Genom att implementera ett särskilt användarkonto med begränsade behörigheter specifikt för din programvara kan du effektivt minska säkerhetsriskerna genom att begränsa omfattningen av den åtkomst som potentiella inkräktare kan försöka utnyttja mot sårbarheter i systemet.
Kopiera nödvändiga filer och skapa en virtuell miljö
Att använda en virtualiserad miljö som är inkapslad i en Docker-container underlättar hanteringen av beroenden eftersom potentiella konflikter med globala programvarupaket och andra program kan undvikas. Dessutom garanteras konsekvens i paketversioner eftersom exakta utgåvor av nödvändiga beroenden kan installeras samtidigt som integriteten i det övergripande systemet bevaras.
Visst! Här är mitt försök att omformulera instruktionerna på ett mer sofistikerat sätt:Följ dessa steg noggrant för att konfigurera kalkylatorprogrammet i Docker-behållaren:1. Först överför du alla viktiga filer från din lokala maskin till den angivna mappen på servern där Docker-avbildningen finns. Denna process innebär kopiering av nödvändiga data för att underlätta en smidig drift av programvaran.2. Använd sedan den effektiva venv -modulen som är förinstallerad med Python för att skapa en isolerad virtuell miljö inuti behållaren. På så sätt kan vi säkerställa att applikationen körs sömlöst utan störningar eller konflikter med andra installerade paket. Syftet med detta steg är att skapa en fristående och säker miljö där kalkylatorprogrammet kan fungera optimalt.
# 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
Att använda virtuella miljöer ger en strömlinjeformad metod för pakethantering inom Docker-containrar, genom att undvika duplicering av systemövergripande komponenter. Detta resulterar i en mer kompakt bildstorlek och minskad resursanvändning under körning.
Minimera lager för effektivitet
Docker använder en copy-on-write-strategi vid konstruktion av avbilder, där varje direktiv i en Dockerfil ger upphov till ytterligare ett lager. För att optimera bilddimensioner och konstruktionshastighet är det klokt att minimera antalet lager som finns i Docker-avbildningen. En praktisk metod för att uppnå detta mål är att kombinera flera instruktioner till ett enda RUN uttalande.
# 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__
Genom att använda de ovan nämnda rekommendationerna kan vi effektivt minimera genereringen av mellanliggande lager under hela konstruktionen av en image.
Säkra konfigurationshantering
Att använda Docker-avbildningar för att hantera känsliga data utgör ett potentiellt säkerhetshot. För att minska denna risk rekommenderas att man använder miljövariabler och externa konfigurationsfiler. I fallet med kalkylatorapplikationen kan man till exempel skapa en katalog som heter “/config” för att hysa konfigurationsfilen och se till att korrekta ägarrättigheter tilldelas.
# Securing Configuration Handling
RUN mkdir /config && chown calculator:calculator /config
Efter att ha placerat en kopia av filen “config.json” i denna mapp samtidigt som den hålls åtskild från applikationens källkod.
# Copy the config.json file into the container
RUN cp config.json /config/config.json
ENV CONFIG_PATH=/config/config.json
Att isolera konfigurationsinformation från kodbasen och implementera lämpliga behörigheter är en viktig aspekt för att stärka den övergripande säkerheten i din Docker-behållare. Detta tillvägagångssätt hindrar obehöriga enheter, t.ex. oseriösa processer eller individer, från att få tillgång till känsliga konfigurationsuppgifter.
Använda byggprocesser i flera steg
Genom att implementera en byggprocess i flera steg kan man isolera byggmiljön från den slutliga grafiska representationen. Följaktligen ger detta tillvägagångssätt mer kompakta och specialiserade slutprodukter. Dessutom ökar säkerheten genom att utvecklingsresurser och data stängs ute från den avslutande bilden. På så sätt minskar angreppsytan och minimerar eventuella risker som kan uppstå till följd av omotiverade inkluderingar.
# 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
Den ovan nämnda koden överför selektivt viktiga komponenter från konstruktionsfasen (kallad byggaren) till den slutliga bilden. Genom att eliminera onödiga byggrelaterade resurser och data effektiviseras bildens dimensioner, vilket säkerställer optimal prestanda för kalkylatorns programvaruapplikation.
Förbättra säkerheten med bildskanning
Använd bildskanningsverktyg som Trivy eller Clair för att öka säkerheten i dina Docker-images.Dessa verktyg är särskilt utvecklade för att upptäcka sårbarheter i bildlager och pålitliga element och erbjuder en robust lösning för att säkerställa integriteten i dina containeriserade applikationer. Du kan t.ex. använda Trivy för att utföra sårbarhetsskanningar på kalkylatorapplikationen.
# 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
Att införliva Trivys sårbarhetsskanningsfunktioner i en Docker-image är av största vikt på grund av dess beroende av den allmänt erkända CVE-databasen (Common Vulnerabilities and Exposures). CVE-databasen ger aktuella uppdateringar om identifierade sårbarheter, vilket möjliggör kontinuerligt underhåll av avbildningens säkerhet genom att implementera de senaste korrigeringarna. Detta minskar potentiella risker i samband med kända exploateringar och skyddar mot obehörig åtkomst eller dataintrång.
För att få en säkerhetsbedömning av din bild kan du använda följande instruktion. Genom att utföra detta kommando får du en omfattande rapport som beskriver alla potentiella svagheter eller mottagligheter som finns i din images programvarukomponenter.
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>
Ovanstående instruktion kan behöva utföras under en längre tid. När den är slutförd skall den därför producera ett dokument som är analogt med följande exempel.
Det är absolut nödvändigt att omedelbart åtgärda en säkerhetslucka i enlighet med dess allvarlighetsgrad, eftersom ju allvarligare problemet är desto snabbare måste det åtgärdas.
Köra program som användare utan behörighet
För att öka säkerheten för det här programmet rekommenderas att du kör det med systemets administratörskonto, vilket minimerar eventuella latenta sårbarheter som kan finnas.
# 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"]
Övergång till en icke-administrativ användare minskar potentiella sårbarheter avsevärt genom att begränsa åtkomsträttigheter och minska omfattningen av potentiella exploateringar.
Containerisering av icke-Python-applikationer
Processen för containerisering av applikationer som använder andra språk än JavaScript kan variera något, vilket kräver förståelse för olika containeriseringstekniker. Genom att förstå dessa nyanser kan man bestämma det optimala tillvägagångssättet för att distribuera sin specifika applikation, med hänsyn till dess programmeringsspråk.