Zum Inhalt springen
Trainingslager IT-Trainingslager

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 User ubuntu in ~/kong-lab. Vom Laptop aus verbindest du dich per SSH.
  • Das Backend ist ein Compose-Projekt: notes-api, Postgres und echo, 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 IPv4

Erwartet (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_IP

Ab hier läuft alles in der VM:

grep PRETTY_NAME /etc/os-release
uname -m

Erwartet:

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 ubuntu

Die 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 Hello

Erwartet:

Docker version 29.9.2, build a82e528
Docker Compose version v5.6.1
Hello from Docker!

Sicherheit: Wer in der Gruppe docker ist, 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/dl

Erwartet:

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-api

Erwartet (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 .url

Erwartet:

0.2.0
"http://echo:8080/get"

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

docker compose -f ~/kong-lab/code/backend/compose.yaml ps --services

Erwartet: drei laufende Dienste (migrate ist fertig und fehlt darum).

db
echo
notes-api
docker network ls --filter name=lab

Erwartet: das Netz lab, in dem ab Tag 1 auch Kong hängt.

NETWORK ID     NAME      DRIVER    SCOPE
53d72b31cbd3   lab       bridge    local
deck version

Erwartet:

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, nie latest.