🥇«Nuove Bulin». Mangiamo l'elefante a pezzetti

In questo articolo configurerò l'ambiente di lavoro per lo sviluppo del gioco "Byliny", e suddividerò il gioco stesso in parti utilizzabili in OpenFaaS. Eseguirò tutte le operazioni su Linux, e farò girare Kubernetes su minikube utilizzando VirtualBox. Il mio computer ha 2 core e 12 GB di RAM, e utilizzo un SSD come disco di sistema. Utilizzerò Debian 8 come sistema principale per lo sviluppo, con i pacchetti emacs, sudo, git e virtualbox già installati; tutto il resto sarà installato scaricando da GitHub e altre fonti. Queste applicazioni saranno installate in /usr/local/bin, se non diversamente specificato. Iniziamo!

Preparazione dell'ambiente di lavoro

Installazione di Go

Seguiamo le istruzioni dal sito ufficiale:

$ curl -L0 https://dl.google.com/go/go1.13.5.linux-amd64.tar.gz -o go.tar.gz
$ sudo tar -C /usr/local -xzf go.tar.gz
$ echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.profile

Verifichiamo il funzionamento:

$ mkdir -p ~/go/src/hello && cd ~/go/src/hello
$ echo 'package main

import "fmt"

func main() {
fmt.Printf("hello, worldn")
}' > hello.go
$ go build
$ ./hello
hello, world

Installazione di faas-cli

Seguiamo le istruzioni dal sito ufficiale:

$ curl -sSL https://cli.openfaas.com | sudo -E sh
x86_64
Downloading package https://github.com/openfaas/faas-cli/releases/download/0.11.3/faas-cli as /tmp/faas-cli
Download complete.

Running with sufficient permissions to attempt to move faas-cli to /usr/local/bin
New version of faas-cli installed to /usr/local/bin
Creating alias 'faas' for 'faas-cli'.
  ___                   _____           ____
 / _  _ __   ___ _ __ |  ___|_ _  __ _/ ___|
| | | | '_  / _  '_ | |_ / _` |/ _` ___ 
| |_| | |_) |  __/ | | |  _| (_| | (_| |___) |
 ___/| .__/_ ___|_| |_|_|  __,_|__,_|____/
      |_| 

CLI:
 commit:  73004c23e5a4d3fdb7352f953247473477477a64
 version: 0.11.3

Inoltre, è possibile attivare il completamento di bash:

faas-cli completion --shell bash | sudo tee /etc/bash_completion.d/faas-cli

Installazione e configurazione di Kubernetes

Per lo sviluppo, minikube è sufficiente, quindi installeremo minikube e kubelet in /usr/local/bin; installeremo anche helm per le applicazioni:

$ curl https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64 -o minikube && chmod +x minikube && sudo mv minikube /usr/local/bin/
$ curl https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl -o kubectl && chmod +x kubectl && sudo mv kubectl /usr/local/bin/
$ curl https://get.helm.sh/helm-v3.0.2-linux-amd64.tar.gz | tar -xzvf - linux-amd64/helm --strip-components=1; sudo mv helm /usr/local/bin

Avviamo minikube:

$ minikube start
  minikube v1.6.2 su Debian 8.11
  Driver 'virtualbox' selezionato automaticamente (alternativi: [])
  Downloading VM boot image ...
    > minikube-v1.6.0.iso.sha256: 65 B / 65 B [--------------] 100.00% ? p/s 0s
    > minikube-v1.6.0.iso: 150.93 MiB / 150.93 MiB [-] 100.00% 5.67 MiB p/s 27s
  Creazione VM virtualbox (CPUs=2, Memory=8192MB, Disk=20000MB) ...
  Preparazione Kubernetes v1.17.0 su Docker '19.03.5' ...
  Downloading kubeadm v1.17.0
  Downloading kubelet v1.17.0
  Pulling images ...
  Launching Kubernetes ...  In attesa che il cluster si attivi ...
  Fatto! kubectl è ora configurato per utilizzare "minikube"

Controlliamo:

$ kubectl get pods --all-namespaces
NAMESPACE     NAME                               READY   STATUS    RESTARTS   AGE
kube-system   coredns-6955765f44-knlcb           1/1     In esecuzione   0          29m
kube-system   coredns-6955765f44-t9cpn           1/1     In esecuzione   0          29m
kube-system   etcd-minikube                      1/1     In esecuzione   0          28m
kube-system   kube-addon-manager-minikube        1/1     In esecuzione   0          28m
kube-system   kube-apiserver-minikube            1/1     In esecuzione   0          28m
kube-system   kube-controller-manager-minikube   1/1     In esecuzione   0          28m
kube-system   kube-proxy-hv2wc                   1/1     In esecuzione   0          29m
kube-system   kube-scheduler-minikube            1/1     In esecuzione   0          28m
kube-system   storage-provisioner                1/1     In esecuzione   1          29m

Installazione di OpenFaaS

Gli sviluppatori consigliano di creare 2 namespace per il lavoro:

$ kubectl apply -f https://raw.githubusercontent.com/openfaas/faas-netes/master/namespaces.yml
namespace/openfaas creato
namespace/openfaas-fn creato

Aggiungiamo il repository per helm:

$ helm repo add openfaas https://openfaas.github.io/faas-netes/
"openfaas" è stato aggiunto ai tuoi repository

Nel chart è possibile impostare una password prima dell'installazione, sfruttiamo questa possibilità e salviamo i dati di accesso come segreto k8s:

$ PASSWORD=verysecurerandompasswordstring
$ kubectl -n openfaas create secret generic basic-auth --from-literal=basic-auth-user=admin --from-literal=basic-auth-password="$PASSWORD"
segreto/basic-auth creato

Eseguendo il deployment:

$ helm repo update
Attendere mentre recuperiamo gli aggiornamenti più recenti dai tuoi repository di chart...
...Aggiornamento completo dal repository di chart "openfaas"
Aggiornamento completato. Buon Helming!
$ helm upgrade openfaas --install openfaas/openfaas --namespace openfaas --set functionNamespace=openfaas-fn --set generateBasicAuth=false
Release "openfaas" non esiste. Installazione in corso.
NOME: openfaas
ULTIMA INSTALLAZIONE: Ven Dic 25 10:28:22 2019
NAMESPACE: openfaas
STATO: installato
REVISIONE: 1
SUITE DI TEST: Nessuna
NOTE:
Per verificare che openfaas sia partito, eseguire:

  kubectl -n openfaas get deployments -l "release=openfaas, app=openfaas"

Dopo un po' di tempo, eseguiamo il comando suggerito:

$ kubectl -n openfaas get deployments -l "release=openfaas, app=openfaas"
NOME                READY   UP-TO-DATE   AVAILABLE   AGE
alertmanager        1/1     1            1           114s
basic-auth-plugin   1/1     1            1           114s
faas-idler          1/1     1            1           114s
gateway             1/1     1            1           114s
nats                1/1     1            1           114s
prometheus          1/1     1            1           114s
queue-worker        1/1     1            1           114s

Verifichiamo il funzionamento:

$ kubectl rollout status -n openfaas deploy/gateway
deplyemento "gateway" completato con successo
$ kubectl port-forward -n openfaas svc/gateway 8080:8080 &
[1] 6985
Inoltro da 127.0.0.1:8080 -> 8080
$ echo -n $PASSWORD | faas-cli login --username admin --password-stdin
Chiamata al server OpenFaaS per convalidare le credenziali...
Gestione della connessione per 8080
ATTENZIONE! La comunicazione non è sicura, si prega di considerare l'uso di HTTPS. Letsencrypt.org offre certificati SSL/TLS gratuiti.
Credenziali salvate per admin http://127.0.0.1:8080
$ faas-cli list
Funzione                        Invocazioni     Repliche

Installazione di Mongodb

Installiamo il tutto utilizzando helm:

$ helm repo add stable https://kubernetes-charts.storage.googleapis.com/
"stable" è stato aggiunto ai tuoi repository
$ helm install stable/mongodb --generate-name
NOME: mongodb-1577466908
ULTIMA INSTALLAZIONE: Ven 25 Dic 11:15:11 2019
NAMESPACE: default
STATI: installato
REVISIONE: 1
TEST SUITE: Nessuno
NOTIZIE:
** Si prega di essere pazienti mentre il chart viene installato **

MongoDB può essere accessibile tramite la porta 27017 al seguente nome DNS all'interno del tuo cluster:

    mongodb-1577466908.default.svc.cluster.local

Per ottenere la password di root esegui:

    export MONGODB_ROOT_PASSWORD=$(kubectl get secret --namespace default mongodb-1577466908 -o jsonpath="{.data.mongodb-root-password}" | base64 --decode)

Per connetterti al tuo database esegui il seguente comando:

    kubectl run --namespace default mongodb-1577466908-client --rm --tty -i --restart='Never' --image bitnami/mongodb --command -- mongo admin --host mongodb-1577466908 --authenticationDatabase admin -u root -p $MONGODB_ROOT_PASSWORD

Per connetterti al tuo database dall'esterno del cluster esegui i seguenti comandi:

    kubectl port-forward --namespace default svc/mongodb-1577466908 27017:27017 &
    mongo --host 127.0.0.1 --authenticationDatabase admin -p $MONGODB_ROOT_PASSWORD

Controlliamo:

kubectl run --namespace default mongodb-1577466908-client --rm --tty -i --restart='Never' --image bitnami/mongodb --command -- mongo admin --host mongodb-1577466908 --authenticationDatabase admin -u root -p $(kubectl get secret --namespace default mongodb-1577466908 -o jsonpath="{.data.mongodb-root-password}" | base64 --decode)
Se non vedi un prompt dei comandi, prova a premere invio.

> db.version();
4.0.14

Premi ctrl+D per uscire dal contenitore.

Configurazione di emacs

In linea di principio, tutto era già configurato secondo questo articolo, quindi non entrerò nei dettagli.

Suddivisione del gioco in funzioni

Le interazioni con le funzioni avvengono tramite il protocollo http, l'autenticazione continua tra le diverse funzioni è garantita da JWT. Per memorizzare i token, così come lo stato del gioco, i dati dei giocatori, le sequenze di mosse di tutti i giochi e altre informazioni viene utilizzato mongodb. Diamo un'occhiata più da vicino alle funzioni più interessanti.

Registrazione

In input a questa funzione è presente un JSON con il soprannome di gioco e la password. Quando viene chiamata questa funzione, viene eseguito un controllo per assicurarsi che il soprannome non sia presente nel database, e in caso di successo, viene inserito il soprannome e l'hash della password nel database. La registrazione è necessaria per partecipare attivamente al gioco.

Ingresso

All'ingresso della funzione c'è un JSON con il soprannome di gioco e la password; se il soprannome è presente nel database e verifica della password è positiva, viene restituito un JWT che deve essere passato ad altre funzioni al momento della loro chiamata. Viene inoltre eseguita l'inserimento nel database di diverse voci di servizio, ad esempio l'ora dell'ultimo accesso e così via.

Visualizzazione dell'elenco giochi

Qualsiasi utente non autorizzato può richiedere l'elenco di tutti i giochi, ad eccezione di quelli attivi. Un utente autorizzato vede anch'esso l'elenco dei giochi attivi. Il risultato della funzione è un JSON contenente le liste di giochi (identificatore del gioco, nome leggibile e così via).

Creazione di un gioco

La funzione funziona solo con utenti autorizzati; in input si prende il numero massimo di giocatori e i parametri del gioco (ad esempio, quali personaggi attivare in questo gioco, il numero massimo di giocatori e così via). Un parametro specifico del gioco è la presenza di una password per unirsi, permettendo di creare giochi non pubblici. Di default viene creato un gioco pubblico. Il risultato dell'esecuzione della funzione è un JSON che contiene un campo di successo della creazione, un identificatore unico del gioco e altri parametri.

Unirsi a un gioco

La funzione funziona solo con utenti autorizzati; in input ci sono l'identificatore del gioco e la sua password, se si tratta di un gioco non pubblico; in output c'è un JSON con i parametri del gioco. L'utente autorizzato che si unisce al gioco e il creatore del gioco vengono poi chiamati partecipanti al gioco.

Visualizzazione degli eventi di gioco

Qualsiasi utente non autorizzato può richiedere l'elenco degli eventi di giochi non attivi, mentre un utente autorizzato può ottenere l'elenco degli eventi di qualsiasi gioco attivo. Un parametro aggiuntivo della funzione può essere il numero dell'evento che l'utente ha già. In questo caso, verranno restituiti solo quegli eventi che sono accaduti dopo. Avviando periodicamente questa funzione, l'utente autorizzato può osservare cosa sta accadendo nel gioco. Inoltre, questa funzione restituisce una richiesta di azione, alla quale l'utente può rispondere tramite la funzione di invio dell'evento di gioco.

Invio di un evento di gioco

La funzione funziona solo per i partecipanti al gioco: viene realizzata la possibilità di avviare il gioco, effettuare una mossa, votare, scrivere un messaggio di testo che appare nell'elenco degli eventi del gioco, e così via.
L'utente autorizzato che ha creato il gioco avvia la distribuzione dei ruoli a tutti i partecipanti, inclusa se stesso, e devono confermare il loro ruolo tramite questa stessa funzione. Una volta che tutti i ruoli sono stati confermati, il gioco passa automaticamente alla modalità notte.

Statistiche di gioco

La funzione funziona solo per i partecipanti al gioco, mostra lo stato del gioco, l'elenco e il numero di giocatori (soprannomi), i ruoli e il loro stato (mossa effettuata o meno), oltre ad altre informazioni. Come per la funzione precedente, tutto funziona solo per i partecipanti al gioco.

Funzioni avviate periodicamente

Se il gioco non è stato avviato per un certo periodo di tempo, specificato durante la creazione del gioco, verrà automaticamente rimosso dall'elenco dei giochi attivi tramite la funzione di pulizia.

Un'altra attività periodica è il passaggio forzato della modalità gioco dalla notte al giorno e viceversa per i giochi nei quali questo non è avvenuto durante la mossa (ad esempio, un giocatore che deve reagire a un evento di gioco non ha inviato la sua decisione per vari motivi).