🧑🏼‍🤝‍🧑🏼 👲🏿 🤲🏽 Quake III Arena, Kubernetes (k3s) y Raspberry Pi 🐾 🧛🏽 😿

Aprox. transl. : Parecería que hasta hace poco la combinación del título parecía una locura imposible. El mundo no se detiene y esta locura se ha vuelto no solo posible, sino incluso realmente simple de implementar. La confirmación se puede encontrar a continuación en la traducción de la instrucción correspondiente de Johan Siebens, un arquitecto de la nube de Bélgica.

Ayer vi este tweet de Chris Campbell en mi feed:

Oh, recuerdos ... Quake III Arena es uno de mis juegos de disparos en primera persona favoritos de todos los tiempos.

Pasé (y perdí) mucho tiempo en el pasado jugando a este juego de ritmo rápido con amigos y enemigos. Ahora, gracias al proyecto QuakeKube de Capital One Tech , el mundo de los contenedores y Kubernetes está abierto a él.

QuakeKube es una versión de Kubernetes de QuakeJS . Para hacer esto, se lanza un servidor Quake 3 dedicado en la implementación correspondiente , al cual los clientes se conectan a través de QuakeJS en el navegador.

Por supuesto, estaba ansioso por probar este proyecto, especialmente después de ver lo siguiente en la documentación:

Las imágenes de contenedor se compilan de forma cruzada con Docker Buildx y pueden ejecutarse en hardware con una variedad de arquitecturas y sistemas operativos. Versiones actualmente disponibles para linux/amd64

y linux/arm64

.

Soporte ARM64! ¡Clase, para que pueda ejecutar Quake en una de mis Raspberry Pi! (Traducción de la nota: más adelante en el artículo consideraremos la opción de instalar k3s en la Raspberry Pi, y si está interesado en Kubernetes regular [vainilla], escribimos sobre esto recientemente ).

Bueno, ¡disparemos!

La mayor parte del trabajo ya ha sido realizado por otros entusiastas, por lo que con las herramientas adecuadas y un plan, solo tomará unos minutos poner el juego en funcionamiento.

Requisitos

Raspberry Pi con Ubuntu 20.04 con soporte ARM64
k3sup

- utilidad ligera para la instalación y configuración automática de k3s en cualquier máquina virtual local o remota;
arkade

- una CLI simple en Golang con indicadores estrictamente definidos, lo que le permite instalar gráficos y aplicaciones en el clúster de manera fácil y sencilla;
kubectl

;
Cuenta de DigitalOcean y token de API.

Instalacion y configuracion

En primer lugar, instale k3s

en una Raspberry Pi con un sistema operativo compatible con ARM64 como Ubuntu 20.04:

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

Después de instalar k3s en la Raspberry Pi, k3sup también descarga el archivo requerido kubeconfig

en el directorio de trabajo actual. Configure kubectl

para usar esta configuración:

$ export KUBECONFIG=$(pwd)/kubeconfig

Ahora arcade

instale el operador de entradas con:

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

El operador de entradas creará un nodo de salida de entradas en DigitalOcean, es decir, proporcionará una dirección IP pública para los servicios LoadBalancer del clúster privado de k3s.

La versión OSS de inlets será suficiente para esto, ya que los clientes se conectan al servidor a través de QuakeJS en un navegador con websockets. Si necesita soporte TLS, etc., le recomiendo que preste atención a la versión PRO.

Finalmente, tome el archivo YAML de QuakeKube del repositorio de GitHub del proyecto y edítelo en consecuencia. El servicio debe reemplazarse por LoadBalancer (en lugar de NodePort). También puedes personalizar los parámetros del juego en sí como desees.

Ejemplo de configuración de YAML para 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

Corriendo

Aplica este manifiesto a tu clúster k3s:


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

Espere hasta que todos los pods se estén ejecutando y el operador de entradas cree su propio nodo de salida:


$ 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

¡Y eso es! ¡Inicie su navegador favorito, descargue la aplicación y comience a disparar en todas las direcciones!

Enlaces útiles

PD del traductor

Puede ver / probar una demostración de QuakeJS en acción aquí .

Lea también en nuestro blog:

Quake III Arena, Kubernetes (k3s) y Raspberry Pi