DevOps-bootcamp · Lektion

Skapa egna Docker-images

Bygg din första egna Docker-image för en enkel applikation och tagga samt versionshantera den korrekt.

Lektion 2 av 412 steg

Skapa egna Docker-images är en gratis lektion i DevOps-bootcamp på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för DevOps-bootcamp, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i DevOps-bootcamp innehåller totalt 4 lektioner.

Bygg din första Docker-avbildning

Varför bygga anpassade avbildningar? De låter dig paketera din specifika applikation, dess beroenden och konfiguration i en enda portabel enhet. Det är avgörande för konsekvens och enkel driftsättning.

Du anger hur avbildningen ska byggas med hjälp av en fil som kallas Dockerfile.

Skapa egna Docker-images — illustration 1

Vår enkla webbapp

Vi ska containerisera en mycket enkel Python Flask-webbapp. Den returnerar bara ”Hello from Docker!” när du besöker dess webbadress.

Föreställ dig att vi har följande filer i en katalog:

app.py: Python-applikationens kod
requirements.txt: En lista över Python-beroenden
Dockerfile: Instruktioner för att bygga avbildningen

Flask-applikationens kod

Det här är vår grundläggande Python-Flask-app. Den lyssnar på port 5000 och svarar med "Hello from Docker!".

Ni kan köra den lokalt (efter att Flask har installerats) för att se den i praktiken!

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello from Docker!'

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0')

Ange beroenden

Vår app behöver Flask-biblioteket. Vi listar det i requirements.txt. Den här filen talar om för Docker (och Pythons pakethanterare, pip) vad som ska installeras.

Detta säkerställer att vår avbildning innehåller alla bibliotek som krävs för att appen ska kunna köras.

Flask==2.3.2

Dockerfilens uppbyggnad

En Dockerfile är en textfil med instruktioner för att bygga en avbildning. Varje instruktion skapar ett lager. Här är det vi kommer att använda:

FROM: Anger basavbildningen (till exempel Python).
WORKDIR: Anger arbetskatalogen inuti containern.
COPY: Kopierar filer från er lokala dator till avbildningen.
RUN: Kör kommandon (till exempel för att installera beroenden).
EXPOSE: Informerar Docker om vilka portar containern lyssnar på.
CMD: Anger standardkommandot som ska köras när containern startar.

Skapa Dockerfilen

Här är den fullständiga Dockerfile för vår Flask-app. Placera den här filen i samma katalog som app.py och requirements.txt.

# Use an official Python runtime as a parent image
FROM python:3.9-slim-buster

# Set the working directory in the container
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY requirements.txt .
COPY app.py .

# Install any needed packages specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Make port 5000 available to the world outside this container
EXPOSE 5000

# Run app.py when the container launches
CMD ["python", "app.py"]

Kommandot `docker build`

Nu ska vi bygga vår avbildning! Öppna terminalen i den katalog där Dockerfile och appfilerna finns.

Flaggan -t märker vår avbildning med ett namn (my-flask-app) och en version (1.0). . anger att Docker ska använda den aktuella katalogen som byggkontext.

docker build -t my-flask-app:1.0 .

Verifiera den nya avbildningen

När bygget är klart kan ni verifiera att den nya avbildningen finns genom att lista alla lokala Docker-avbildningar.

Leta efter my-flask-app med taggen 1.0 i resultatet.

docker images

Starta appens container

Nu är det dags att se appen i praktiken! Använd docker run för att skapa och starta en container från avbildningen.

-p 5000:5000 kopplar port 5000 på värddatorn till port 5000 inuti containern. -d kör den i frikopplat läge (i bakgrunden).

docker run -d -p 5000:5000 my-flask-app:1.0

Besök http://localhost:5000 i webbläsaren för att se "Hello from Docker!".

Bästa praxis för taggning av avbildningar

Taggar är avgörande för att hantera olika versioner av era avbildningar. En vanlig metod är att använda semantisk versionshantering (till exempel 1.0.0, 2.1.5) samt en latest-tagg.

Ni kan lägga till flera taggar i en avbildning med hjälp av docker tag:

docker tag my-flask-app:1.0 my-flask-app:latest

Detta gör att ni kan hänvisa till samma avbildning med olika namn, vilket ger flexibilitet vid driftsättning.

Snabb kontroll

Studera följande Dockerfile och byggkommando:

# Dockerfile content
FROM alpine:latest
WORKDIR /app
COPY . .
CMD ["echo", "Hello"]

docker build -t my-app:v1 .

Vilket av följande påståenden är SANT om kommandot docker build -t my-app:v1 .?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Egna avbildningar

Bra jobbat! Ni har lärt er att:

Förbereda en enkel applikation för containerisering.
Skriva en grundläggande Dockerfile med viktiga instruktioner (FROM, WORKDIR, COPY, RUN, EXPOSE, CMD).
Bygga en egen Docker-avbildning med docker build -t.
Verifiera avbildningen med docker images.
Köra en container från den egna avbildningen med docker run -p.
Förstå betydelsen av taggning och versionshantering av avbildningar.

Härnäst går vi djupare in på hur Docker-avbildningar är uppbyggda av lager och på tekniker för att optimera deras storlek och byggtider!

Gratis att börja

Lär dig DevOps-bootcamp med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 142
Lektioner: 568

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Skapa egna Docker-images” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen DevOps-bootcamp, inklusive ”Skapa egna Docker-images”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i DevOps-bootcamp innehåller totalt 4 lektioner.

Vad lär jag mig i ”Skapa egna Docker-images”?

Bygg din första egna Docker-image för en enkel applikation och tagga samt versionshantera den korrekt. Ni övar på DevOps-bootcamp med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig DevOps-bootcamp?

Du behöver inga förkunskaper. Utbildningen i DevOps-bootcamp på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Skapa egna Docker-images”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här DevOps-bootcamp-lektionen?

Ja. Varje DevOps-bootcamp-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till DevOps-bootcamp