Tag 0: Das Trainingsgelände
Ziel: Die Labor-VM anlegen, Docker und decK installieren, den Begleitcode holen und das Backend starten, das Kong ab Tag 1 veröffentlicht. · Dauer: ca. 45 min · Voraussetzung: keine
Briefing
- Gearbeitet wird in der Ubuntu-24.04-VM
kong, als Userubuntuin~/kong-lab. Vom Laptop aus verbindest du dich per SSH. - Das Backend ist ein Compose-Projekt:
notes-api, Postgres undecho, ein Dienst, der jede Anfrage samt Headern zurückspiegelt. - Das Backend veröffentlicht keinen Port. Ab Tag 1 ist Kong die einzige Tür.
- Alle Container hängen im Docker-Netz
lab.
Laptop VM kong
┌─────────┐ ssh ┌──────────────────────────────────────────────┐
│ Browser │───────►│ ~/kong-lab/ setup/ code/ tagNN/ │
│ ssh │ │ Netz lab: notes-api :8080 db :5432 echo :8080│
└─────────┘ │ (kein Port nach außen) │
└──────────────────────────────────────────────┘
Drill 1: Die Labor-VM
Auf dem Laptop (Multipass von multipass.run). Der zweite
Befehl hinterlegt deinen SSH-Schlüssel in der VM, damit du ab Tag 1
Tunnel bauen kannst:
multipass launch 24.04 --name kong --cpus 2 --memory 4G --disk 30G
multipass exec kong -- bash -c "echo '$(cat ~/.ssh/id_ed25519.pub)' \
>> ~/.ssh/authorized_keys"
multipass info kong | grep IPv4Erwartet (gekürzt, die IP weicht bei dir ab):
Launched: kong
IPv4: 192.168.64.7
Merk dir die IP als KONG_IP und melde dich an:
export KONG_IP=192.168.64.7
ssh ubuntu@$KONG_IPAb hier läuft alles in der VM:
grep PRETTY_NAME /etc/os-release
uname -mErwartet:
PRETTY_NAME="Ubuntu 24.04.5 LTS"
x86_64
Auf einem Mac mit Apple Silicon steht hier aarch64.
Docker, Kong und decK gibt es für beide Architekturen; die Befehle
dieses Buchs wählen die passende selbst.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Docker installieren
Docker CE kommt aus dem Paket-Repository von Docker, nicht aus Ubuntu:
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
-o /etc/apt/keyrings/docker.asc
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] \
https://download.docker.com/linux/ubuntu $(. /etc/os-release; echo $VERSION_CODENAME) \
stable" | sudo tee /etc/apt/sources.list.d/docker.list
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io \
docker-buildx-plugin docker-compose-plugin jq
sudo usermod -aG docker ubuntuDie Gruppe docker gilt erst nach einer neuen Anmeldung.
Melde dich ab (exit), wieder an
(ssh ubuntu@$KONG_IP) und prüfe:
docker --version
docker compose version
docker run --rm hello-world | grep HelloErwartet:
Docker version 29.9.2, build a82e528
Docker Compose version v5.6.1
Hello from Docker!
Sicherheit: Wer in der Gruppe
dockerist, hat faktisch root-Rechte auf der VM. Im Labor ist das in Ordnung, auf einem gemeinsam genutzten Server nicht.
Fortschritt speichern? Kostenlos registrieren
Drill 3: decK installieren
decK ist Kongs Werkzeug für deklarative Konfiguration (Tag 3). Ein Release-Binary installierst du in vier Schritten: laden, Prüfsumme prüfen, auspacken, installieren.
mkdir -p /tmp/dl && cd /tmp/dl
V=1.69.0
ARCH=$(dpkg --print-architecture)
B=https://github.com/Kong/deck/releases/download/v$V
curl -fsSLO "$B/deck_${V}_linux_${ARCH}.tar.gz"
curl -fsSLO "$B/checksums.txt"
sha256sum --check --ignore-missing checksums.txt
tar xzf "deck_${V}_linux_${ARCH}.tar.gz" deck
sudo install deck /usr/local/bin/
deck version
cd ~ && rm -rf /tmp/dlErwartet:
deck_1.69.0_linux_amd64.tar.gz: OK
decK v1.69.0 (7b20626)
--ignore-missing prüft nur die Datei, die du geladen
hast. Steht dort nicht OK, installierst du nichts.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Begleitcode und Arbeitsverzeichnis
mkdir -p ~/kong-lab && cd ~/kong-lab
git clone https://github.com/thomaszachmann/kong-zum-anfassen.git code
mkdir -p setup && cp code/setup/env.sh setup/
source ~/kong-lab/setup/env.sh
ls code
echo "$ADMIN $PROXY"Erwartet (gekürzt):
Cloning into 'code'...
LICENSE README.md backend keycloak kong notes observability plugins setup …
http://localhost:8001 http://localhost:8000
setup/env.sh liest du jeden Morgen ein.
$ADMIN ist Kongs Admin API, $PROXY der Eingang
für Clients. code/ bleibt unverändert; deine Arbeit landet
in tagNN/.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Das Image von notes-api
notes-api ist die Go-API aus „Dockerfiles zum Anfassen”. Bau das Image einmal:
cd ~/kong-lab/code/notes/notes-api
docker build -q --build-arg VERSION=0.2.0 -t notes-api:0.2.0 .
docker images notes-apiErwartet (gekürzt, beim ersten Mal ein bis zwei Minuten):
sha256:7b0d2646bc6e…
IMAGE ID DISK USAGE CONTENT SIZE EXTRA
notes-api:0.2.0 7b0d2646bc6e 16.4MB 4.5MB
16 MB: ein statisches Go-Binary auf scratch.
GET /notes ist offen, POST /notes verlangt den
Header X-API-Key. Genau diese Prüfung übernimmt ab Tag 5
Kong.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Das Backend starten
cd ~/kong-lab/code/backend
docker compose up -d --wait
docker compose ps --format "table {{.Service}}\t{{.Status}}\t{{.Ports}}"Erwartet (gekürzt):
Container backend-db-1 Healthy
Container backend-echo-1 Healthy
Container backend-notes-api-1 Healthy
SERVICE STATUS PORTS
db Up 9 seconds (healthy) 5432/tcp
echo Up 8 seconds 8080/tcp
notes-api Up 2 seconds (healthy) 8080/tcp
Die Spalte PORTS zeigt nur Ports im
Netz lab, keine Pfeile nach außen. Von der VM aus erreichst
du die Dienste nur über einen Container im selben Netz:
docker run --rm --network lab curlimages/curl:8.17.0 -s notes-api:8080/version
docker run --rm --network lab curlimages/curl:8.17.0 -s echo:8080/get | jq .urlErwartet:
0.2.0
"http://echo:8080/get"
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
docker compose -f ~/kong-lab/code/backend/compose.yaml ps --servicesErwartet: drei laufende Dienste (migrate ist fertig und
fehlt darum).
db
echo
notes-api
docker network ls --filter name=labErwartet: das Netz lab, in dem ab Tag 1 auch Kong
hängt.
NETWORK ID NAME DRIVER SCOPE
53d72b31cbd3 lab bridge local
deck versionErwartet:
decK v1.69.0 (7b20626)
Challenge
Leg mit notes-api eine Notiz an, ohne einen Port des Backends nach außen zu öffnen. Prüf danach, dass sie in Postgres liegt.
Hinweis: Der curl-Container aus Drill 6 kann auch
POST; den Schlüssel findest du in compose.yaml.
Lösung
docker run --rm --network lab curlimages/curl:8.17.0 -s -X POST \
-H 'X-API-Key: lab-api-key-123' -H 'Content-Type: application/json' \
-d '{"text":"vor dem Gateway"}' notes-api:8080/notes
docker compose -f ~/kong-lab/code/backend/compose.yaml exec db \
psql -U notes -d notes -c 'select text from notes'Erwartet (gekürzt):
{"id":"ba87895f-…","text":"vor dem Gateway"}
text
-----------------
vor dem Gateway
(1 row)
Ohne Kong muss jeder Client den Schlüssel der API kennen und direkt
ins Netz lab kommen. Beides ändert sich ab morgen.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Kein Port nach außen: Backends hinter einem Gateway sind nur im internen Netz erreichbar. Das Gateway ist die einzige Stelle, die von außen kommt.
- Secrets: Die Lab-Werte stehen hier im Klartext in
compose.yaml. In Produktion kommen sie aus Docker-Secrets, einem Vault oder Kongs Secret-Referenzen ({vault://…}). - Binaries prüfen: Jedes heruntergeladene Werkzeug wird gegen die Prüfsumme des Herstellers geprüft, besser noch gegen eine Signatur („Container-Tools zum Anfassen”).
- Versionen pinnen:
notes-api:0.2.0,postgres:18.6-alpine, nielatest.