Installera Docker och din första container

Modul 9: Docker och docker compose · Lästid: 11 minuter

Lärandemål: Efter den här lektionen kan du installera Docker Engine från den officiella paketkällan, starta containrar, granska dem, titta in i dem och städa bort dem, och du vet varför gruppen docker är likvärdig med root.

Nyckelbegrepp: Docker Engine, Docker Desktop, officiell apt-källa, docker.io från Debian, gruppen docker, rootless mode, docker run, -d, -p, -v, --name, docker ps, docker logs, docker exec, docker stop, docker rm, docker image prune, docker system df

Vilken Docker?

På en server installerar du Docker Engine: bakgrundstjänsten (dockerd) plus kommandot docker. Docker Desktop är något annat: ett program med fönster för Windows, macOS och Linux-skrivbord. Det hör inte hemma på en server.

Det finns två bra källor för Docker Engine:

1. Dockers egen paketkälla (download.docker.com). Alltid den senaste versionen, inklusive insticksprogrammet docker compose som du använder i lektion 9.3. Det är detta som Docker-dokumentationen beskriver och som den här kursen använder.
2. Paketet docker.io från Debian eller Ubuntu. Äldre, men uppdateras av distributionen via dina vanliga säkerhetsuppdateringar (lektion 4.2). Utmärkt om du helst inte vill ha något utanför distributionen; kontrollera då att docker compose (med ett mellanslag) finns tillgängligt.

Välj en av dem. Att installera båda om vartannat ger konflikter; därför säger Docker-dokumentationen att du först ska ta bort inofficiella paket som docker.io, docker-compose och podman-docker.

Installera från Dockers paketkälla

Här är stegen från Docker-dokumentationen för Debian, med nyckeln separat och en egen Signed-By (lektion 4.1). Ta gärna en snapshot först om du vill.

anna@web1:~$ sudo apt update
anna@web1:~$ sudo apt install ca-certificates curl
anna@web1:~$ sudo install -m 0755 -d /etc/apt/keyrings
anna@web1:~$ sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
anna@web1:~$ sudo chmod a+r /etc/apt/keyrings/docker.asc

Sedan källfilen /etc/apt/sources.list.d/docker.sources (deb822-format):

Types: deb
URIs: https://download.docker.com/linux/debian
Suites: trixie
Components: stable
Architectures: amd64
Signed-By: /etc/apt/keyrings/docker.asc

Vid Suites anger du kodnamnet för din version (cat /etc/os-release, lektion 4.3) och vid Architectures utdata från dpkg --print-architecture. På Ubuntu är URL:en https://download.docker.com/linux/ubuntu och sviten till exempel noble.

Installera sedan:

anna@web1:~$ sudo apt update
anna@web1:~$ sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
anna@web1:~$ sudo docker run hello-world
...
Hello from Docker!
This message shows that your installation appears to be working correctly.

På Debian och Ubuntu startar Docker automatiskt efter installationen och även efter varje omstart (systemctl status docker, lektion 6.1).

Observera: unattended-upgrades (lektion 4.2) uppdaterar som standard inte paket från den här källan automatiskt. Lägg in sudo apt update && sudo apt upgrade för Docker i din underhållsrytm (lektion 10.4), eller lägg medvetet till källan i dina automatiska uppdateringar.

Gruppen docker är root

Överallt på internet står det att du ska lägga till dig själv i gruppen docker, så att du inte längre behöver skriva sudo:

anna@web1:~$ sudo usermod -aG docker anna

Gör det bara om du förstår vad det innebär. Docker-dokumentationen är tydlig: gruppen docker ger rättigheter på root-nivå. Den som får styra Docker-tjänsten kan starta en container med hela värdens disk monterad i den:

docker run -it -v /:/host debian chroot /host

och är därmed root på din server, utan lösenord och utan sudo-logg. Docker-dokumentationen säger det så här: bara betrodda användare ska få styra Docker-tjänsten.

För en server som bara du själv administrerar är det ett val: bekvämlighet mot en extra väg till root. Säkrare är att helt enkelt fortsätta skriva sudo docker ...; då hamnar varje kommando i sudo-loggen (lektion 3.2). Lägg i alla fall aldrig till en användare i gruppen som inte får vara root, till exempel en tjänsteanvändare för en webbplats.

Rootless mode

Docker kan också köras utan root: tjänsten och containrarna körs då under en vanlig användare, med ett eget user namespace. Du installerar det som den användaren med dockerd-rootless-setuptool.sh install (från paketet docker-ce-rootless-extras; i förväg behövs paketet uidmap). En sårbarhet i en container ger då inte root på värden. Det finns begränsningar och det är krångligare att sätta upp; i den här kursen använder vi den vanliga installationen och håller den säker med reglerna i den här modulen.

En första riktig container

Vi startar en nginx-webbserver i en container, som bara kan nås från servern själv:

anna@web1:~$ sudo docker run -d --name proef -p 127.0.0.1:8080:80 nginx:stable
Unable to find image 'nginx:stable' locally
stable: Pulling from library/nginx
...
3f1c9e0d7a2b...

Delarna:

Kontrollera:

anna@web1:~$ sudo docker ps
CONTAINER ID   IMAGE          COMMAND                  STATUS         PORTS                    NAMES
3f1c9e0d7a2b   nginx:stable   "/docker-entrypoint.…"   Up 5 seconds   127.0.0.1:8080->80/tcp   proef
anna@web1:~$ curl -I http://127.0.0.1:8080
HTTP/1.1 200 OK
Server: nginx/1.28.0
anna@web1:~$ sudo ss -tlnp | grep 8080
LISTEN 0 4096 127.0.0.1:8080 0.0.0.0:* users:(("docker-proxy",pid=2211,fd=7))

ss (lektion 5.1) bekräftar: bara på 127.0.0.1. Om du hade skrivit -p 8080:80 hade det stått 0.0.0.0:8080 och [::]:8080, och din container hade gått att nå från internet, även om ufw inte släpper igenom port 8080 (lektion 9.3). Versionen i Server-headern kan vara en annan hos dig.

Titta runt och ingripa

anna@web1:~$ sudo docker logs proef            # det programmet skrev (stdout och stderr)
anna@web1:~$ sudo docker logs -f --tail 20 proef   # de senaste 20 raderna och fortsätt följa
anna@web1:~$ sudo docker exec -it proef sh     # ett skal i den körande containern
# cat /etc/os-release
# exit
anna@web1:~$ sudo docker stop proef
anna@web1:~$ sudo docker start proef
anna@web1:~$ sudo docker rm -f proef           # stoppa och ta bort

docker logs är det första stället du tittar på när en container inte gör det du förväntar dig, precis som journalctl för vanliga tjänster (lektion 6.2). Med docker exec tittar du in, men ändra helst inget där: ändringar i containern försvinner vid nästa uppdatering (lektion 9.1).

Städa

Images och stoppade containrar ligger kvar tills du städar bort dem. På en VPS med liten disk växer det obemärkt.

anna@web1:~$ sudo docker system df
TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
Images          7         3         1.9GB     1.2GB (63%)
Containers      3         3         12MB      0B (0%)
Local Volumes   2         2         180MB     0B (0%)
Build Cache     0         0         0B        0B
anna@web1:~$ sudo docker image prune

docker image prune tar bort namnlösa images som inte längre hör till något; med -a även alla images som inte används av någon container. Var försiktig med docker system prune --volumes: det tar även bort anonyma volymer (utan namn) som just då inte hör till någon container, och docker volume prune -a till och med volymer med namn. Där kan dina data ligga. Ge därför alltid volymer ett namn eller använd en bind mount (lektion 9.1), och titta först med docker volume ls.

Containrarnas loggar kan också växa. Docker sparar dem som standard i JSON-filer utan storleksgräns. En gräns sätter du i /etc/docker/daemon.json:

{
  "log-driver": "json-file",
  "log-opts": { "max-size": "10m", "max-file": "3" }
}

Därefter sudo systemctl restart docker; inställningen gäller bara nyskapade containrar, befintliga containrar skapar du på nytt.

I praktiken

Docker fungerar på en VPS hos WebOké precis som hos alla andra leverantörer: det är programvara i din egen server, som du själv installerar och uppdaterar. På en liten VPS bör du regelbundet kontrollera diskutrymmet med docker system df och df -h (lektion 1.4).

Sammanfattning

• Installera Docker Engine från Dockers paketkälla (med egen nyckel och Signed-By) eller docker.io från distributionen, inte båda.
• Gruppen docker är likvärdig med root; sudo docker lämnar ett spår i sudo-loggen. Rootless mode är ett säkrare men mer begränsat alternativ.
• docker run -d --name ... -p 127.0.0.1:host:container image:tag startar en container som bara kan nås lokalt; kontrollera med ss.
• docker ps, logs, exec, stop, rm är dina dagliga verktyg.
• Städa images med docker image prune, begränsa containerloggar (som standard obegränsade) och var sparsam med --volumes.

Quiz

Uppgift

Uppgift O9.2: Din första container. Installera Docker Engine på din server enligt lektionen (eller på en testmaskin). Starta en nginx-container som bara lyssnar på 127.0.0.1:8080, kontrollera med docker ps, curl -I och ss -tlnp, titta på loggarna och städa sedan bort den. Svara på frågorna: från vilken källa installerade du Docker, vad visade ss för port 8080, och lade du till dig själv i gruppen docker (varför eller varför inte)?

Läs mer

• Docker-dokumentationen, Install Docker Engine on Debian: https://docs.docker.com/engine/install/debian/
• Docker-dokumentationen, Install Docker Engine on Ubuntu: https://docs.docker.com/engine/install/ubuntu/
• Docker-dokumentationen, Linux post-installation steps: https://docs.docker.com/engine/install/linux-postinstall/
• Docker-dokumentationen, Docker security (Docker daemon attack surface): https://docs.docker.com/engine/security/
• Docker-dokumentationen, Rootless mode: https://docs.docker.com/engine/security/rootless/
• Docker-dokumentationen, JSON File logging driver: https://docs.docker.com/engine/logging/drivers/json-file/