🚴🏻 🕺 🏴‍☠️ Quake III Arena, Kubernetes (k3s) und Raspberry Pi 🧑 😹 💤

Ca. übers. : Es scheint, dass die Kombination des Titels bis vor kurzem wie ein unmöglicher Wahnsinn schien. Die Welt steht nicht still und dieser Wahnsinn ist nicht nur möglich, sondern auch wirklich einfach umzusetzen. Bestätigung lesen Sie unten in Übersetzung der entsprechenden Anweisung von Johan Siebens - Cloud-Architekt aus Belgien.

Gestern habe ich diesen Tweet von Chris Campbell in meinem Feed gesehen:

Oh, Erinnerungen ... Quake III Arena ist einer meiner Lieblings-Ego-Shooter aller Zeiten.

Ich habe in der Vergangenheit viel Zeit damit verbracht (und verloren), dieses rasante Spiel mit Freunden und Feinden zu spielen. Dank des QuakeKube- Projekts von Capital One Tech ist die Welt der Container und Kubernetes jetzt offen dafür.

QuakeKube ist eine Kubernetes-Version von QuakeJS . Zu diesem Zweck wird in der entsprechenden Bereitstellung ein dedizierter Quake 3- Server gestartet , zu dem Clients über QuakeJS im Browser eine Verbindung herstellen.

Natürlich wollte ich dieses Projekt unbedingt ausprobieren, insbesondere nachdem ich Folgendes in der Dokumentation gesehen habe:

Container-Images werden mit Docker Buildx überkompiliert und können auf Hardware mit einer Vielzahl von Architekturen und Betriebssystemen ausgeführt werden. Derzeit verfügbare Versionen für linux/amd64

und linux/arm64

.

ARM64-Unterstützung! Klasse, damit ich Quake auf einem meiner Raspberry Pi ausführen kann! (Übersetzung beachten: Später in diesem Artikel werden wir die Möglichkeit in Betracht ziehen, k3s auf dem Raspberry Pi zu installieren. Wenn Sie an regulären [Vanille] Kubernetes interessiert sind, haben wir kürzlich darüber geschrieben .)

Nun, lass uns schießen!

Der größte Teil der Arbeit wurde bereits von anderen Enthusiasten erledigt. Mit den entsprechenden Tools und einem vorgefertigten Plan dauert der Start des Spiels nur wenige Minuten.

Bedarf

Raspberry Pi unter Ubuntu 20.04 mit ARM64-Unterstützung
k3sup

- leichtes Dienstprogramm für die automatische Installation und Konfiguration von k3s auf einer lokalen oder entfernten virtuellen Maschine;
arkade

- eine einfache CLI in Golang mit genau definierten Flags, mit der Sie Diagramme und Anwendungen einfach und problemlos in einem Cluster installieren können;
kubectl

;;
DigitalOcean-Konto und API-Token.

Installation und Konfiguration

Installieren Sie zunächst k3s

auf einem Raspberry Pi mit einem ARM64-kompatiblen Betriebssystem wie Ubuntu 20.04:

$ k3sup install --ip 192.168.0.52 --user ubuntu --k3s-extra-args '--no-deploy servicelb --no-deploy traefik'

Nach der Installation von k3s auf dem Raspberry Pi lädt k3sup auch die erforderliche Datei kubeconfig

in das aktuelle Arbeitsverzeichnis herunter . Konfigurieren Sie kubectl

die Verwendung dieser Konfiguration:

$ export KUBECONFIG=$(pwd)/kubeconfig

Jetzt arcade

die Einlässe-Betreiber installieren mit:

$ arkade install inlets-operator --provider digitalocean --token-file ~/do-api-token

Der Einlässe-Operator eines sogenannten schaffen Einlässe austritt Knoten auf DigitalOcean, d.h. stellt eine öffentliche IP-Adresse für die LoadBalancer-Dienste des privaten Clusters von k3 bereit.

Hierzu ist die OSS-Version der Einlässe ausreichend, da Clients über QuakeJS in einem Browser mit Websockets eine Verbindung zum Server herstellen. Wenn Sie TLS-Unterstützung usw. benötigen, empfehle ich, auf die PRO-Version zu achten.

Nehmen Sie zum Schluss die QuakeKube YAML-Datei aus dem GitHub-Repository des Projekts und bearbeiten Sie sie entsprechend. Der Dienst sollte durch LoadBalancer (anstelle von NodePort) ersetzt werden. Sie können auch die Parameter des Spiels selbst nach Ihren Wünschen anpassen.

Beispiel für eine YAML-Konfiguration für QuakeKube:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: quakejs
spec:
  selector:
    matchLabels:
      run: quakejs
  replicas: 1
  template:
    metadata:
      labels:
        run: quakejs
      annotations:
        prometheus.io/scrape: 'true'
        prometheus.io/port: '8080'
    spec:
      containers:
      - command:
        - q3
        - server
        - --config=/config/config.yaml
        - --content-server=http://localhost:9090
        - --agree-eula
        image: docker.io/criticalstack/quake:v1.0.5
        name: server
        ports:
        - containerPort: 8080
        readinessProbe:
          tcpSocket:
            port: 8080
          initialDelaySeconds: 15
          periodSeconds: 5
        volumeMounts:
        - name: quake3-server-config
          mountPath: /config
        - name: quake3-content
          mountPath: /assets
      - command:
        - q3
        - content
        - --seed-content-url=http://content.quakejs.com
        image: docker.io/criticalstack/quake:v1.0.5
        name: content-server
        ports:
        - containerPort: 9090
        volumeMounts:
        - name: quake3-content
          mountPath: /assets
      volumes:
        - name: quake3-server-config
          configMap:
            name: quake3-server-config
        - name: quake3-content
          emptyDir: {}
---
apiVersion: v1
kind: Service
metadata:
  name: quakejs
spec:
  type: LoadBalancer
  selector:
    run: quakejs
  ports:
    - port: 80
      targetPort: 8080
      name: http
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: quake3-server-config
data:
  config.yaml: |
    fragLimit: 25
    timeLimit: 15m
    bot:
      minPlayers: 3
    game:
      motd: "Welcome to Critical Stack"
      type: FreeForAll
      forceRespawn: false
      inactivity: 10m
      quadFactor: 3
      weaponRespawn: 3
    server:
      hostname: "quakekube"
      maxClients: 12
      password: "changeme"
    commands:
      - addbot sarge 2
    maps:
    - name: q3dm7
      type: FreeForAll
      timeLimit: 10m
    - name: q3dm17
      type: FreeForAll
    - name: q3wctf1
      type: CaptureTheFlag
      captureLimit: 8
    - name: q3tourney2
      type: Tournament
    - name: q3wctf3
      type: CaptureTheFlag
      captureLimit: 8
    - name: ztn3tourney1
      type: Tournament

Laufen

Wenden Sie dieses Manifest auf Ihren k3s-Cluster an:


$ kubectl apply -f example.yaml 
deployment.apps/quakejs created
service/quakejs created
configmap/quake3-server-config created

Warten Sie, bis alle Hülsen werden laufen und Einlässen-Operator erzeugt einen eigenen Ausgang-Knoten:


$ kubectl get pods,service
NAME                                         READY   STATUS    RESTARTS   AGE
pod/inlets-operator-76fb794578-s2fg4         1/1     Running   0          147m
pod/quakejs-tunnel-client-6f7c986dfc-mdt5w   1/1     Running   0          50s
pod/quakejs-786cc496b-g7b7n                  2/2     Running   0          80s

NAME                 TYPE           CLUSTER-IP    EXTERNAL-IP                       PORT(S)        AGE
service/kubernetes   ClusterIP      10.43.0.1     <none>                            443/TCP        152m
service/quakejs      LoadBalancer   10.43.46.33   143.110.174.204,143.110.174.204   80:32116/TCP   80s

Und alle! Starten Sie Ihren Lieblingsbrowser, laden Sie die Anwendung herunter und beginnen Sie mit dem Schießen in alle Richtungen!

Nützliche Links

PS vom Übersetzer

Sie können eine Demo von QuakeJS in Aktion sehen / versuchen hier .

Lesen Sie auch in unserem Blog:

Quake III Arena, Kubernetes (k3s) und Raspberry Pi