👲🏼 🗽 ⛲️ Quake III Arena, Kubernetes (k3s) e Raspberry Pi 🤘🏾 👴 🖌️

Aproximadamente. trad. : parece que até recentemente a combinação do título parecia uma loucura impossível. O mundo não pára, e essa loucura se tornou não apenas possível, mas também muito simples de implementar. Confirmação lida abaixo na tradução da instrução correspondente de Johan Siebens - arquiteto de nuvem da Bélgica.

Ontem eu vi este tweet de Chris Campbell no meu feed:

Oh, memórias ... Quake III Arena é um dos meus jogos de tiro em primeira pessoa favoritos de todos os tempos.

Passei (e perdi) muito tempo no passado jogando este jogo acelerado com amigos e inimigos. Agora, graças ao projeto QuakeKube da Capital One Tech , o mundo dos contêineres e do Kubernetes está aberto para isso.

QuakeKube é uma versão Kubernetes do QuakeJS . Para fazer isso, um servidor Quake 3 dedicado é lançado na implantação correspondente , ao qual os clientes se conectam via QuakeJS no navegador.

Claro, eu estava ansioso para experimentar este projeto, especialmente depois de ver o seguinte na documentação:

As imagens de contêiner são compiladas cruzadas com o Docker Buildx e podem ser executadas em hardware com uma variedade de arquiteturas e sistemas operacionais. Versões atualmente disponíveis para linux/amd64

e linux/arm64

.

Suporte para ARM64! Classe, para que eu possa executar o Quake em um dos meus Raspberry Pi! (Observação da tradução: posteriormente neste artigo, consideraremos a opção de instalar o k3s no Raspberry Pi e, se você estiver interessado no Kubernetes [vanilla] regular, escrevemos recentemente sobre isso .)

Bem, vamos atirar!

A maior parte do trabalho já foi feito por outros entusiastas, então com as ferramentas certas e um plano, levará apenas alguns minutos para iniciar o jogo.

Requisitos

Raspberry Pi executando Ubuntu 20.04 com suporte para ARM64
k3sup

- utilitário leve para instalação automática e configuração de k3s em qualquer máquina virtual local ou remota;
arkade

- um CLI simples em Golang com sinalizadores estritamente definidos, permitindo que você instale facilmente gráficos e aplicativos em um cluster;
kubectl

;
Conta DigitalOcean e token de API.

Instalação e configuração

Em primeiro lugar, instale k3s

em um Raspberry Pi com um sistema operacional compatível com ARM64, como o Ubuntu 20.04:

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

Depois de instalar o k3s no Raspberry Pi, o k3sup também baixa o arquivo necessário kubeconfig

para o diretório de trabalho atual. Configure kubectl

para usar esta configuração:

$ export KUBECONFIG=$(pwd)/kubeconfig

Agora arcade

instale o operador de entrada com:

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

O operador de entradas criará um chamado nó de saída de entradas no DigitalOcean, ou seja, fornecerá um endereço IP público para os serviços LoadBalancer do cluster privado k3s.

Para isso, a versão OSS dos inlets será suficiente, pois os clientes se conectam ao servidor via QuakeJS em um navegador com websockets. Se você precisar de suporte TLS, etc., recomendo prestar atenção à versão PRO.

Finalmente, pegue o arquivo QuakeKube YAML do repositório GitHub do projeto e edite-o de acordo. O serviço deve ser substituído por LoadBalancer (em vez de NodePort). Você também pode personalizar os parâmetros do próprio jogo como desejar.

Exemplo de configuração 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

Corrida

Aplique este manifesto ao seu cluster k3s:


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

Aguarde até que todos os pods estejam em execução e inlets-operator crie seu próprio nó de saída:


$ 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

E é isso! Abra seu navegador favorito, baixe o aplicativo e comece a atirar em todas as direções!

Links Úteis

PS do tradutor

Você pode ver / experimentar uma demonstração do QuakeJS em ação aqui .

Leia também em nosso blog:

Quake III Arena, Kubernetes (k3s) e Raspberry Pi