Quake III Arena, Kubernetes (k3s) et Raspberry Pi

Environ. trad. : il semblerait que jusqu'Ă  rĂ©cemment la combinaison du titre semblait ĂȘtre une folie impossible. Le monde ne s'arrĂȘte pas, et cette folie est devenue non seulement possible, mais mĂȘme trĂšs simple Ă  mettre en Ɠuvre. La confirmation se trouve ci-dessous dans la traduction de l'instruction correspondante de Johan Siebens, un architecte cloud de Belgique.







Hier, j'ai vu ce tweet de Chris Campbell dans mon fil d'actualité:





Oh, souvenirs ... Quake III Arena est l'un de mes tireurs à la premiÚre personne préférés de tous les temps.



J'ai passé (et perdu) beaucoup de temps dans le passé à jouer à ce jeu rapide avec des amis et des ennemis. Désormais, grùce au projet QuakeKube de Capital One Tech , le monde des conteneurs et Kubernetes lui est ouvert.



QuakeKube est une version Kubernetes de QuakeJS . Pour ce faire, un serveur Quake 3 dédié est lancé dans le déploiement correspondant , auquel les clients se connectent via QuakeJS dans le navigateur.


Bien sûr, j'avais hùte d'essayer ce projet, surtout aprÚs avoir vu ce qui suit dans la documentation:



Les images de conteneurs sont compilées de maniÚre croisée avec Docker Buildx et peuvent s'exécuter sur du matériel avec une variété d'architectures et de systÚmes d'exploitation. Versions actuellement disponibles pour linux/amd64



et linux/arm64



.


Prise en charge ARM64! Classe, pour que je puisse exĂ©cuter Quake sur l'un de mes Raspberry Pi! (Remarque sur la traduction: plus loin dans l'article, nous examinerons l'option d'installer k3 sur le Raspberry Pi, et si vous ĂȘtes intĂ©ressĂ© par Kubernetes [vanilla] classique, nous en avons parlĂ© rĂ©cemment .)



Eh bien, tirons!



La plupart du travail a déjà été effectué par d'autres passionnés, donc avec les bons outils et un plan, il ne faudra que quelques minutes pour lancer le jeu.



Exigences



  • Raspberry Pi exĂ©cutant Ubuntu 20.04 avec prise en charge ARM64
  • k3sup



    - utilitaire léger pour l'installation et la configuration automatiques de k3 sur n'importe quelle machine virtuelle locale ou distante;
  • arkade



    - une simple CLI dans Golang avec des indicateurs strictement définis, vous permettant d'installer facilement et facilement des graphiques et des applications dans un cluster;
  • kubectl



    ;
  • Compte DigitalOcean et jeton API.


Installation et configuration



Tout d'abord, installez k3s



sur un Raspberry Pi avec un systĂšme d'exploitation compatible ARM64 comme Ubuntu 20.04:



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





AprÚs avoir installé k3s sur le Raspberry Pi, k3sup télécharge également le fichier requis kubeconfig



dans le répertoire de travail actuel. Configurez kubectl



pour utiliser cette configuration:



$ export KUBECONFIG=$(pwd)/kubeconfig
      
      





Maintenant, arcade



installez l'opérateur inlets avec:



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





L'opĂ©rateur des entrĂ©es crĂ©era un soi-disant nƓud de sortie des entrĂ©es sur DigitalOcean, c.-Ă -d. fournira une adresse IP publique pour les services LoadBalancer du cluster privĂ© k3s.



La version OSS des inlets suffira pour cela, puisque les clients se connectent au serveur via QuakeJS dans un navigateur avec websockets. Si vous avez besoin du support TLS, etc., je vous recommande de prĂȘter attention Ă  la version PRO.



Enfin, rĂ©cupĂ©rez le fichier YAML QuakeKube dans le rĂ©fĂ©rentiel GitHub du projet et modifiez-le en consĂ©quence. Le service doit ĂȘtre remplacĂ© par LoadBalancer (au lieu de NodePort). Vous pouvez Ă©galement personnaliser les paramĂštres du jeu lui-mĂȘme comme vous le souhaitez.



Exemple de configuration YAML pour 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
      
      





Fonctionnement



Appliquez ce manifeste Ă  votre cluster k3s:




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





Attendez que tous les pods soient en cours d'exĂ©cution et que l'opĂ©rateur d'inlets crĂ©e son propre nƓud de sortie:




$ 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
      
      





Et c'est tout! Lancez votre navigateur préféré, téléchargez l'application et commencez à photographier dans toutes les directions!





Liens utiles





PS du traducteur



Vous pouvez voir / essayer une démo de QuakeJS en action ici .



Lisez aussi sur notre blog:






All Articles