Docker: Åtgärda bildsårbarheter med Trivy och Copa

Docker-containerbilder innehåller ofta säkerhetssårbarheter som är ärvda från deras grundläggande operativsystemspaket. Istället för att bygga om bilder från början kan du använda Trivy för att skanna efter sårbarheter och Copa för att åtgärda dem direkt. Denna handledning visar hur man identifierar och fixar containersårbarheter på Ubuntu-, Debian-, RHEL-, CentOS- och Fedora-system med dessa två kraftfulla öppen källkodsverktyg.

I den här handledningen kommer du att lära dig:

Hur man installerar Trivy-sårbarhetsskanner på Ubuntu/Debian
Hur man installerar Copa-behållarens patchverktyg
Hur man skannar Docker-bilder efter OS-sårbarheter
Hur man automatiskt åtgärdar sårbarheter i containrar
Hur man verifierar att patchade bilder är fria från sårbarheter

Sammanfattning av artikeln: Skanna Docker-bilder efter sårbarheter med Trivy och åtgärda dem automatiskt med Copa.

Steg	Kommando/Åtgärd
1. Skanna bild	`sudo trivy image --vuln-type os --ignore-unfixed IMAGE_NAME`
2. Exportera JSON-rapport	`trivy image --vuln-type os --ignore-unfixed -f json -o report.json IMAGE_NAME`
3. Starta BuildKit	`sudo docker run --detach --rm --privileged -p 127.0.0.1:8888:8888/tcp --name buildkitd --entrypoint buildkitd moby/buildkit:v0.11.4 --addr tcp://0.0.0.0:8888`
4. Fäst bild	`sudo copa patch -i IMAGE_NAME -r report.json -t patched -a tcp://0.0.0.0:8888`

Steg 1: Installera Trivy-sårbarhetsskannern

Trivy är en öppen källkod sårbarhetsskanner utvecklad av Aqua Security. Den upptäcker sårbarheter i OS-paket, applikationsberoenden och containerbilder.

Ubuntu/Debian

Installera beroenden: Installera först paketen wget och gnupg som krävs för att lägga till arkivet:
```
$ sudo apt-get install wget gnupg -y
```

Lägg till Trivy GPG-nyckel: Ladda ner och lägg till Trivy-förrådets signeringsnyckel:

$ wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | gpg --dearmor | sudo tee /usr/share/keyrings/trivy.gpg > /dev/null

Lägg till Trivy-förråd: Lägg till det officiella Trivy-förrådet till din källista:

$ echo "deb [signed-by=/usr/share/keyrings/trivy.gpg] https://aquasecurity.github.io/trivy-repo/deb generic main" | sudo tee -a /etc/apt/sources.list.d/trivy.list

Installera Trivy: Uppdatera paketlistan och installera Trivy:
```
$ sudo apt-get update
$ sudo apt-get install trivy -y
```

RHEL/CentOS/Fedora

Lägg till Trivy-förvaret: Skapa Trivy-repo-filen:

# sudo tee /etc/yum.repos.d/trivy.repo << 'EOF'
[trivy]
name=Trivy repository
baseurl=https://aquasecurity.github.io/trivy-repo/rpm/releases/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://aquasecurity.github.io/trivy-repo/rpm/public.key
EOF

Installera Trivy: Använd dnf eller yum för att installera:
```
# sudo dnf install trivy -y
```

Verifiera installationen genom att kontrollera versionen:

$ trivy --version

Steg 2: Installera Copa Patching Tool

Copa (Copacetic) är ett CNCF-sandboxprojekt som patchar containerbilder direkt utan att kräva en fullständig ombyggnad. Det använder sårbarhetsrapporter från skannrar som Trivy för att applicera säkerhetsuppdateringar. Copa distribueras som en enda binärfil som fungerar på alla Linux-distributioner.

Ladda ner Copa-binärfilen: Hämta den förbyggda binärfilen från den officiella Copa GitHub-releasesida:

$ wget https://github.com/project-copacetic/copacetic/releases/download/v0.9.0/copa_0.9.0_linux_amd64.tar.gz

Packa upp arkivet: Packa upp den nedladdade tarballen:
```
$ tar -xzf copa_0.9.0_linux_amd64.tar.gz
```
Installera Copa: Flytta binärfilen till din systemväg:
```
$ sudo mv copa /usr/local/bin/
```
Verifiera installation: Bekräfta att Copa är korrekt installerad:
```
$ copa --version
```

Steg 3: Skanna containerbilden efter sårbarheter

Innan du patchar behöver du identifiera sårbarheter i din containerbild. Följande steg använder linuxconfig/instantprivacy som exempel – ersätt det med ditt eget bildnamn.

Ladda ner containerbilden: Ladda ner bilden du vill skanna:
```
$ sudo docker pull linuxconfig/instantprivacy
```
Sök efter sårbarheter: Kör Trivy för att söka efter sårbarheter på operativsystemnivå. Flaggan --ignore-unfixed utesluter sårbarheter utan tillgängliga lösningar:
```
$ sudo trivy image --vuln-type os --ignore-unfixed linuxconfig/instantprivacy
```

Exportera JSON-rapport: Copa kräver att skanningsresultaten är i JSON-format:

$ trivy image --vuln-type os --ignore-unfixed -f json -o instantprivacy.json linuxconfig/instantprivacy

Steg 4: Patcha behållarbild med Copa

Copa använder BuildKit för att applicera patchar på containerbilder.

Starta BuildKit-behållare: Starta BuildKit som en privilegierad behållare:

$ sudo docker run --detach --rm --privileged \
  -p 127.0.0.1:8888:8888/tcp \
  --name buildkitd \
  --entrypoint buildkitd \
  moby/buildkit:v0.11.4 \
  --addr tcp://0.0.0.0:8888

Verifiera att BuildKit körs: Bekräfta att containern startade framgångsrikt:
```
$ sudo docker ps
```
Patcha containerbilden: Använd Copa för att applicera säkerhetspatchar. Flaggan -t anger taggen för den patchade bilden:
```
$ sudo copa patch \
  -i docker.io/linuxconfig/instantprivacy \
  -r instantprivacy.json \
  -t patched \
  -a tcp://0.0.0.0:8888
```
Copa laddar ner säkerhetsuppdateringar och skapar ett nytt bildlager med tillämpade patchar. Den patchade bilden kommer att märkas som linuxconfig/instantprivacy:patched.

Steg 5: Verifiera patchad bild

Skanna den patchade bilden: Bekräfta att alla sårbarheter har åtgärdats:

$ sudo trivy image --vuln-type os --ignore-unfixed linuxconfig/instantprivacy:patched

Testa den patchade bilden: Kontrollera att den patchade bilden körs korrekt:

$ sudo docker run --name=instantprivacy -d -p 8118:8118 linuxconfig/instantprivacy:patched
$ export http_proxy="http://localhost:8118"
$ curl api.ipify.org
45.84.107.174

Rengöring: Stoppa BuildKit-containern när den är klar:
```
$ sudo docker stop buildkitd
```

Slutsats

Du har framgångsrikt skannat en Docker-containerbild efter säkerhetssårbarheter med Trivy och patchat dem automatiskt med Copa. Detta tillvägagångssätt är snabbare än att bygga om bilder från grunden och lägger endast till ett enda patchlager, vilket bevarar den ursprungliga bildens struktur. För produktionsmiljöer, integrera dessa verktyg i din CI/CD-pipeline för att automatiskt skanna och patcha containerbilder innan distribution. För mer information, se den officiella dokumentationen för Trivy och Copas projektwebbplats.

Vanliga frågor

Vilka typer av sårbarheter kan Copa åtgärda? Copa åtgärdar endast sårbarheter i operativsystemnivåpaket (som Debian-, Ubuntu-, Alpine- eller RHEL-paket). Den kan inte åtgärda sårbarheter i applikationsnivåberoenden som npm-paket, Python pip-moduler eller Go-moduler. För dessa behöver du bygga om applikationen med uppdaterade beroenden.
Varför behöver jag BuildKit för att köra Copa? Copa använder BuildKits diff- och sammanslagningsfunktioner för att skapa ett nytt bildlager som endast innehåller de patchade filerna. BuildKit körs som en privilegierad container som hanterar låg-nivå manipulation av bilden. Utan BuildKit kan inte Copa tillämpa patchar på containerfilesystemet.
Kan jag patcha bilder från privata register? Ja, Copa stödjer privata register. Du behöver autentisera med docker login innan du kör patch-kommandot. Copa använder dina Docker-referenser för att hämta basbilden och trycka den patchade versionen om det behövs.
Vad händer om Copa inte kan åtgärda alla sårbarheter? Vissa sårbarheter kanske ännu inte har några tillgängliga lösningar. --ignore-unfixed-flaggan i Trivy exkluderar dessa från rapporten. Copa kommer att åtgärda allt som har en tillgänglig lösning. Kör Trivy igen utan --ignore-unfixed för att se alla sårbarheter, inklusive de som väntar på korrigeringar.
Hur uppdaterar jag Copa till den senaste versionen? Ladda ner den senaste versionen från Copa GitHub-releasesidan och ersätt binärfilen i /usr/local/bin/. Kontrollera nuvarande version med copa --version.