Microservices - PokeFumi

Poke-fu-mi est une application qui permet d'organiser des combats entre maîtres Pokémon mais les règles ne sont pas exactement celles du jeu classique.

Besoins

1. En tant que joueur, je peux …

   1. m'inscrire à la plateforme avec un nom d'utilisateur unique.
   2. me connecter à la plateforme utilisant mon nom d’utilisateur et un mot de passe
   3. voir la liste de joueurs (avec leur score)
   4. voir la liste de matchs
   5. voir les détails d’un match: joueurs, Pokémons utilisés, etc
   6. inviter un autre joueur à un match (creer un match)
   7. consulter les invitations reçues
   8. accepter une invitation à un match (joindre un match existant)
   9. créer un deck pour un match
   10. envoyer un Pokémon à l’arena et consulter le résultat du combat (le joueur n'envoie pas un Pokémon en particulier mais envoie un deck, donc au moins un Pokémon, à l'arena)

2. En tant qu’administrateur, je peux …

   1. me connecter à la plateforme utilisant mon nom d’utilisateur et un mot de passe
   2. voir la liste de joueurs
   3. voir la liste de matchs
   4. effacer et modifier les joueurs et les matchs
   5. consulter les statistiques de la plateforme : nombre de matchs par jour, nombre de matchs par pokemon, nombre de victoires par pokemon, etc

TODO requirements :

• ajouter un service de statistiques générés à partir de log, avec kafka ou Elastic Stack.

Comment utiliser l'application

Installation

1. Ajout les variables d'environnement

A la racine des dossiers suivants : users-api et match-api ajouter des fichiers .env comportant les informations suivantes :

DATABASE_URL="postgres://User:Password@Host.db.User.com/User?schema=public"
USERS_API_BASE_URL="http://localhost"
USERS_API_PORT="3000"
MATCH_API_BASE_URL="http://localhost"
MATCH_API_PORT="3100"
SECRET="an awesome secret for our token"

Pour DATABASE_URL, on pourra utiliser des bases de données pgSQL proposées par le service suivant : ElephantSQL - PostgreSQL as a Service.

Si le schéma de la base de données est différent de celui indiqué dans les schémas de prisma, une erreur peut survenir. Dans ce cas on pourra remplacer la commande RUN npx prisma db push par RUN npx prisma db push --accept-data-loss dans les fichiers de configuration docker de users-api et de match-api, mais ceci écrasera les données existantes.

2. Exécution des commandes suivantes

git clone https://github.com/reifocS/IMT-pokefumi-microservices.git
cd ./IMT-pokefumi-microservices
docker compose build
docker compose up

Documentation - Requêtes

Des exemples de requêtes sont données pour être exécutées avec l'extension chrome Open Talend Api teste, Celles-ci sont disponibles dans le dossier test.

Ressources

Diagramme d'intégration

graph TB
    subgraph Légende
    A((Humain))
    S_I{{Service interne}}
    S_E[Service externe]
    D[(Base de données)]
    end

Loading

graph LR
    %%variable
    U((Utilisateur))
    S_RP{{Reverse Proxy}}
    S_U{{Service des profils<br/><br/>- Login, Logout<br/>- Gestion des decks}}
    D_U[(pgSQL<br/><br/>- Profil<br/>- Deck)]
    S_M{{Service des matchs<br/><br/>- Combat<br/>- Invitation}}
    D_M[(pgSQL<br/><br/>- Match<br/>- Round)]
    S_P[Service Poke-API]
    %%relation
    U ---> S_RP
    S_U --- D_U
    S_RP <--> S_U & S_M ---> S_P
    S_M --- D_M
    %%structure
    subgraph Pokefumi Application
        subgraph Internal Network        
        S_RP
        S_U
        S_M
        end
    D_U
    D_M
    end

Loading

Les bases de données utilisées étaient au départ en local avec SQLite mais comme ce type de base de données ne supporte pas les enumérations alors que ce projet est réalisé en TypeScript qui supporte cette puissante fonctionnalité, nous avons décidé d'utiliser des bases de données de type pqSQL.

Sélection du deck pour un match

sequenceDiagram
    %%variable
    actor U as Joueur
    participant S_U as Service des profils
    participant S_M as Service des matchs
    %%sequence
    U ->> S_U : Connection (Pseudo, Mot de passe)
    activate S_U
    S_U -->> U : Token (utilisateur)
    deactivate S_U
    U ->>+ S_M : Choix du deck pour un match (Deck, Match, Token)
    S_M ->>+ S_U : Evaluation du deck (Deck, Token du joueur)
    S_U -->>- S_M : Validation du propriétaire du deck
    S_M -->>- U : Confirmation du choix du deck

Loading

Diagramme de base de données

Structure des dossiers

• Le répertoire users-api contiendra le microservice pour répondre aux besoins de connexions et de gestion du profil utilisateur.
• Le répertoire match-api contiendra le microservice pour répondre aux besoins des matchs (e.g. matchmaking, combat).
• Le répertoire proxy contiendra les configurations pour le proxy.

Connaissances acquises

Typescript

• TypeScript Exercises

Formatting

• How to add ESLint and Prettier to a React TypeScript Project (2022) | by André Borba Netto Assis | JavaScript in Plain English

Principes des microservices

• Les microservices, qu'est-ce que c'est ?
• Microservice Architecture — Learn, Build, and Deploy Applications - DZone Microservices

Prisma database

• Getting started with Prisma, the best TypeScript ORM | by Dries Augustyns | CodeX | Medium
• Database connectors | Prisma Docs

Proxy

• Vidéo sur la comparaison d'un proxy et d'un reverse proxy
• Comparaison des méthodes de reverse proxing with nginx
• Comprendre le serveur Nginx et les algorithmes de sélection de blocs de localisation
• nginx.conf example

Docker

Pour exécuter des applications Windows et Linux sur des systèmes d'exploitation (OS) différents, il est nécessaire de répliquer l'environnement requis pour celles-ci. Pour se faire, deux méthodes existent : les machines virtuelles (VMs) et les conteneurs.

La comparaison de l'architecture de ces technologies montrent que pour exécuter des applications les VMs répliquent un OS indépendant et s'appuient directement sur le matériel informatique. Les conteneurs quand à eux permettent l'exécution d'applications sur l'OS hôte sans en répliquer d'autres, et s'appuient sur son kernel (noyau de l'OS hôte).

Par ailleurs, le développement, le déploiement et la gestion des applications des conteneurs sont plus simples pour les conteneurs que pour les VMs.

Dans le cadre de ce projet de microservices, une isolation totale avec des ressources garanties n'est pas nécessaire, ainsi on préfèrera la technologie des conteneurs. L'outils permettant de gérer les configurations de conteneurs le plus utilisé est Docker.

Ressources utiles

• introduction
  • Que sont les conteneurs ? | Atlassian
  • Best practices for writing Dockerfiles
  • Docker Nodejs Tutorial
• réseau
  • Dealing with ports in a Docker
  • Docker Compose Network - documentation
  • Understanding Docker Networking Drivers and their use cases
  • Docker Compose Network - pratical
  • Adresse IP : débuter avec le calcul des masques de sous-réseaux
• debbuging
  • Visual Studio Code Remote Development
  • Debugging Node.js Applications in Docker

To launch our application in containers

Executer les commandes suivantes à la racine du répertoire

docker compose build
docker compose up

Dockerfile

Un petit exemple :

FROM node:17.0.1

WORKDIR /match-api/

# dependencies
COPY . .
RUN npm install

# database
COPY prisma prisma
RUN npx prisma db push
RUN npx prisma generate

CMD ["npm", "run", "build-start"]

EXPOSE 3100

Chaque instruction crée une couche :

• FROM pour créer une couche à partir de l'image Docker node:17.0.1.
• WORKDIR pour définir le répertoire de travail.
• COPY pour ajouter des fichiers depuis le répertoire courant (répertoire pouvant être défini par le docker-compose.yml) dans le dît répertoire de travail du client Docker (les fichiers du .dockerignore ne seront pas copiés).
• RUN pour préparer l'environnement.
• CMD pour spécifier une commande / un script à exécuter dans le conteneur afin de lancer l'image construite.
• EXPOSE pour informer sur quel port l'application écoute.

Commandes

Création et Exécution d'un seul conteneur

docker build -t matchs:v1 .
docker run --publish 5000:3000/tcp matchs:v1 # permettant d'autoriser le transfert des requêtes sur le port `5000` de l'hôte vers le port `3000` du conteneur.

Création et Exécution d'applications multi-containeurs

docker compose build # à faire que si l'on modifie les dockers files
docker compose up # start et monopolisation du shell (on Ctrl+C avant de relancer le shell), la monopolisation peut être empêchée avec --detach
docker compose start # start et rend la main sur le shell après (on peut restart facilement)
docker compose restart # docker compose stop + docker compose start (nécessaire pour mettre à jour l'architecture docker)

Autres commandes

Commands	Purposes
docker ps	List running containers
docker images	List local images
docker rmi <ImageName>	Remove an image from local registry
docker pull [ImageName:tag]	Download an image from registry (docker hub)
docker exec -it <ContainerId> bash	Access running container (command line)
docker stop <ContainerId>	Stop a running container
docker network ls	List all the networks the Engine daemon knows about
docker network inspect <NetworkName>	Return information about the selected NetworkName network