Ett vanligt användningsområde för Docker är att skapa och köra virtuella Pythonmiljöer. Med en Dockerfile och Docker Compose kan vi automatisera hela processen, från skapandet av miljön till exekveringen.

Bild: Volker Lekies

Som exempelprogram kommer vi att göra ett litet Pythonprogram som hämtar aktuell temperatur för Ängelholm via SMHIs öppna API. Temperaturen, tillsammans med aktuell tidsstämpel, kommer att skrivas ut på skärmen. Programmet körs i en loop och hämtar ny temperatur var femte minut.

Utdata från programmet kommer att se ut så här:

Temperatur i Ängelholm (2022-07-24 17:00:00): 20.4C

Förberedelser

För detta projektet behöver du docker compose på din dator. Använder du Debian eller Ubuntu installerar du det med apt install docker-compose-plugin. Använder du Fedora, Red Hat eller CentOS använder du dnf install docker-compose-plugin. Detta förutsätter att du använder dig av Dockers officiella paketförråd.

När du har installerat Docker Compose är det dags att skapa en ny katalog för projektet och gå in i den. Jag döper min katalog till temperatur:

$> mkdir temperatur
$> cd temperatur

Vi behöver också skapa en katalog för koden:

$> pwd
/home/jake/temperatur
$> mkdir kod

Pythonprogrammet

I kod-katalogen skapar vi nu Pythonprogrammet för att hämta temperaturen. Filnamnet ska vara temperatur.py.

~/temperatur/kod/temperatur.py

import requests
import time
import datetime
url = "http://opendata-download-metobs.smhi.se/api/version/1.0/parameter/1/station/62180/period/latest-hour/data.json"

while True:
    data = requests.get(url).json()
    timestamp = data['updated'] / 1000 # SMHIs tidstämpel är i millisekunder
    humandate = datetime.datetime.fromtimestamp(timestamp)
    print("Temperatur i Ängelholm (" + str(humandate) + "):", data['value'][0]['value'] + "C")
    time.sleep(300)

Därefter skapar vi en requirements.txt. I denna lägger vi de moduler vi behöver installera i den virtuella Pythonmiljön. I vårt fall är det bara requests:

~/temperatur/kod/requirements.txt

requests

Dockerfilerna

I temperatur-katalogen skapar vi nu de två Dockerfilerna, Dockerfile och docker-compose.yml. Filen Dockerfile används för att bygga Docker-avbilden, och docker-compose.yml används för att initiera bygget av avbilden samt för att starta och stoppa containern.

~/temperatur/Dockerfile

FROM debian:stable-slim
RUN apt-get update && apt-get install -y python3 python3-venv tzdata

# Skapa inte __pycache__
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# Sätt svensk tidszon
ENV TZ="Europe/Stockholm"

# Pythonmiljön
ENV VIRTUAL_ENV=/opt/venv

# Sätt upp Pythonmiljön
RUN python3 -m venv $VIRTUAL_ENV
ENV PATH="$VIRTUAL_ENV/bin:$PATH"

# Kopiera koden
RUN mkdir /kod
COPY kod/requirements.txt /kod
COPY kod/temperatur.py /kod
RUN pip install -r /kod/requirements.txt

# Kör programmet
WORKDIR /kod
CMD ["python", "temperatur.py"]

~/temperatur/docker-compose.yml

version: "3.8"

services:
  temperatur:
    restart: unless-stopped
    build: .

Starta stacken

Nu kan vi starta hela miljön, eller stacken som det också kallas, med docker compose up. När vi kör detta kommer avbilden att byggas. I avbilden kommer en virtuell Pythonmiljö att skapas som innehåller de moduler som behövs. Här sätts även sökvägen till Pythontolkaren (till den i den virtuella Pythonmiljön) och programmet som ska köras. När bygget är klart startas en container av avbilden.

$> pwd
/home/jake/temperatur
$> docker compose up
[+] Building 21.8s (13/13) FINISHED                                        
 => [internal] load build definition from Dockerfile                     0.1s
 => => transferring dockerfile: 595B                                     0.0s
 => [internal] load .dockerignore                                        0.1s
 => => transferring context: 2B                                          0.0s
 => [internal] load metadata for docker.io/library/debian:stable-slim    1.0s
 => CACHED [1/8] FROM docker.io/library/debian:stable-slim@sha256:4e67   0.0s
 => [internal] load build context                                        0.1s
 => => transferring context: 597B                                        0.0s
 => [2/8] RUN apt-get update && apt-get install -y python3 python3-venv 12.9s
 => [3/8] RUN python3 -m venv /opt/venv                                  2.8s
 => [4/8] RUN mkdir /kod                                                 0.5s 
 => [5/8] COPY kod/requirements.txt /kod                                 0.1s 
 => [6/8] COPY kod/temperatur.py /kod                                    0.1s 
 => [7/8] RUN pip install -r /kod/requirements.txt                       3.1s 
 => [8/8] WORKDIR /kod                                                   0.1s 
 => exporting to image                                                   0.7s 
 => => exporting layers                                                  0.7s 
 => => writing image sha256:9490d40b43e99e212a85e8121524716f76c6d069a25b 0.0s 
 => => naming to docker.io/library/temperatur_temperatur                 0.0s 

Use 'docker scan' to run Snyk tests against images to find vulnerabilities 
and learn how to fix them

[+] Running 2/2
 ⠿ Network temperatur_default         Created                            0.1s
 ⠿ Container temperatur-temperatur-1  Created                            0.1s
Attaching to temperatur-temperatur-1
temperatur-temperatur-1  | Temperatur i Ängelholm (2022-07-24 18:00:00): 20.0C

Var femte minut kommer en ny rad med aktuell temperatur att skrivas ut från containern. Den temperatur vi hämtar från SMHI uppdateras dock bara en gång per timme, men för att demonstrera hämtar vi den var femte minut.

För att stoppa miljön, tryck CTRL+C.

Demonstration

Kommentarer

Kommentarsfältet är modererat. Det innebär att alla kommentarer granskas av ansvarig utgivare före publicering.

Du väljer själv om du vill ange ditt riktiga namn, en pseudonym eller vara helt anonym. Ingen registrering behövs.