Lab 08 : Exemples d'Architectures n-tiers

Objectifs

Dans cet atelier, vous allez :

Déployer un exemple d’architecture multi-niveau
Identifier les méthodes et ressources OUTSCALE permettant de déployer cette architecture multi-niveau

Application et architecture

Dans cet atelier, vous apprendrez à mettre en place système de gestion électronique de documents qui est GED Mayan hautement disponible, soutenue par une base de données PostgreSQL.

Mayan est une GED open source basée sur le web et écrite en Python. Mayan s’installe et s’exécute par défaut (par conception) sur un seul système ; tous les composants de votre application et de votre base de données peuvent se trouver sur un seul serveur ou dans plusieurs conteneurs Docker. Bien que cela soit parfait pour les tests ou les environnements triviaux, pour un environnement de production, nous voulons une haute disponibilité et un concept largement connu et adopté connu sous le nom de principe SoC (Separation of Concern). Il s’agit d’une meilleure pratique cruciale pour la construction d’applications stratifiées et évolutives.

Nous allons déployer cette application sur le Cloud 3DS OUTSCALE avec une architecture 2-tiers. Cette architecture de référence montre comment le faire avec Mayan.

Sur chaque niveau on va utiliser des services 3DS OUTSCALE. Cette architecture utilise :

Un NET (vpc)
5 subnets
- Un subnet public
- Deux subnets privés dans une availability zone (a)
- Deux subnets privés dans une autre availability zone (b)
Une VM bastion sur le subnet public afin d’assurer la connectivité vers les VM composant cette application
Une NAT gateway pour assurer l’accès à internet pour les VM de l’application
Un répartiteur de charge relié à internet (load balancer) pour distribuer les flux entrants venant d’internet entre les instances qui composent le frontend de l’application. Ce load balancer est accessible depuis internet, c’est le point d’entrée pour cette application
Un répartiteur de charge interne qui va distribuer le trafic entre les instances depuis les instances frontend vers les instances backend de l’application. Ce load balancer est accessible uniquement à l’intérieur du NET
Deux VM réparties sur des zones de disponibilités différentes pour la partie frontend de l’application
Deux VM sur des zones de disponibilités différentes pour accueillir les composants backend de l’application

Voici une visualisation d’ensemble de cette architecture.

Architecture N-Tiers

Déploiement

Pour déployer cette application, suivez les étapes suivantes :

On va commencer par créer la partie réseau.

Créez un NET avec le CIDR 10.0.1.0/16
Créez un internet service IGW1
Associez cette gateway au NET
Créez un subnet public PUBLIC-SUBNET avec un CIDR 10.0.1.0/24
- Créez une table de routage ROUTE-TABLE-0 à associer au PUBLIC-SUBNET
- Ajoutez une route depuis l’ID de IGW1 vers 0.0.0.0/0
Créez un service NAT NATGW1 sur ce subnet avec une IP publique
Créez un subnet privé PRIVATE-SUBNET-1 dans la zone de disponibilité a dont le CIDR est 10.0.2.0/24
- Créez une table de routage ROUTE-TABLE-1 à associer au PRIVATE-SUBNET-2
- Ajoutez une route depuis l’ID de NATGW1 vers 0.0.0.0/0
Créez un subnet privé PRIVATE-SUBNET-2 dans la zone de disponibilité b dont le CIDR est 10.0.3.0/24
- Créez une table de routage ROUTE-TABLE-2 à associer au PRIVATE-SUBNET-2
- Ajoutez une route depuis l’ID de NATGW1 vers 0.0.0.0/0
Créez un subnet privé PRIVATE-SUBNET-3 dans la zone de disponibilité a dont le CIDR est 10.0.4.0/24
- Créez une table de routage ROUTE-TABLE-3 à associer au PRIVATE-SUBNET-3
- Ajoutez une route depuis l’ID de NATGW1 vers 0.0.0.0/0
Créez un subnet privé PRIVATE-SUBNET-4 dans la zone de disponibilité b dont le CIDR est 10.0.5.0/24
- Créez une table de routage ROUTE-TABLE-4 à associer au PRIVATE-SUBNET-4
- Ajoutez une route depuis l’ID de NATGW1 vers 0.0.0.0/0
Créez un load balancer relié à internet InternetLB sur le subnet PUBLIC-SUBNET
- Ajouter un listener avec les paramètres suivants à ce load balacner
  - Protocol : TCP
  - Load Balancer Port : 80
  - Instance Port : 80
- Ajouter un Health Check avec les paramètres suivants
  - Target : TCP:80
  - Interval : 30
  - Timeout : 5
  - Unhealthy Threshold : 5
  - Healthy Threshold : 10
Créez un security group sgInternetLB à associer au load balancer InternetLB avec les règles suivantes
- Service : http
- Type : inbound
- Protocol : tcp
- From Port: 80
- To Port: 80
- CIDR: 0.0.0.0/0
Créez un load balancer interne PrivateLB sur le subnet PRIVATE-SUBNET-3
- Ajoutez un listener avec les paramètres suivants
  - Protocol : TCP
  - Load Balancer Port : 5432
  - Instance Port : 5432
- Ajoutez un Health Check avec les paramètres suivants
  - Target : TCP:5432
  - Interval : 30
  - Timeout : 5
  - Unhealthy Threshold : 5
  - Healthy Threshold : 10
Créez un security group sgPrivateLB à associer au load balancer PrivateLB avec les règles suivantes
- Règle 1
  - Service : Custom
  - Type : inbound
  - Protocol : tcp
  - From Port: 5432
  - To Port: 5432
  - CIDR: CIDR de subnet PRIVATE-SUBNET-1 10.0.2.0/24
- Règle 2
  - Service : Custom
  - Type : inbound
  - Protocol : tcp
  - From Port: 5432
  - To Port: 5432
  - CIDR: CIDR de subnet PRIVATE-SUBNET-2 10.0.3.0/24

Passons maintenant à la création des VM. Pour toutes les VM on va utiliser l’OMI pour ubuntu 22.04 ami-cd8d714e, la taille de disque 20Get le type de disque gp2

Créez une keypair à associer aux VMs
Créez une VM VMBastion dans le subnet PUBLIC-SUBNET avec une IP publique et la taille tinav6.c1r2p2
- Créez une security group sgBastion à associer à cette VM avec les règles suivantes :
  - Service : SSH
  - Type : inbound
  - Protocol : tcp
  - From Port: 22
  - To Port: 22
  - CIDR: 0.0.0.0/0
Créez une VM VM1 dans le subnet PRIVATE-SUBNET-1 avec la taille tinav6.c2r4p2
- Créez une security group sgFront à associez pour cette VM avec les règles suivantes
  - Règle 1
    - Service : HTTP
    - Type : inbound
    - Protocol : tcp
    - From Port: 80
    - To Port: 80
    - CIDR: CIDR de subnet PUBLIC-SUBNET 10.0.1.0/24
  - Règle 2
    - Service : SSH
    - Type : inbound
    - Protocol : tcp
    - From Port: 22
    - To Port: 22
    - Group: l’ID de security group sgBastion
Créez une VM VM2 dans le subnet PRIVATE-SUBNET-2 avec la taille tinav6.c2r4p2
- Associez la security group sgFront pour cette VM
Créez une VM VM3 dans le subnet PRIVATE-SUBNET-3 avec la taille tinav6.c2r4p2
- Créez une security group sgBack à associer pour cette VM avec les règles suivantes
  - Règel 1
    - Service : Custom
    - Type : inbound
    - Protocol : tcp
    - From Port: 5432
    - To Port: 5432
    - CIDR: CIDR de subnet PRIVATE-SUBNET-3 10.0.4.0/24
  - Règle 2
    - Service : Custom
    - Type : inbound
    - Protocol : tcp
    - From Port: 5432
    - To Port: 5432
    - CIDR: CIDR de subnet PRIVATE-SUBNET-4 10.0.5.0/24
  - Règle 3
    - Service : Custom
    - Type : inbound
    - Protocol : tcp
    - From Port: 5432
    - To Port: 5432
    - Group: Security group de load balancer interne sgPrivateLB.
  - Règle 4
    - Service : SSH
    - Type : inbound
    - Protocol : tcp
    - From Port: 22
    - To Port: 22
    - Group: l’ID de security group sgBastion
Créez une VM VM4 dans le subnet PRIVATE-SUBNET-4 avec la taille tinav6.c2r4p2
- Associez la security group sgBack pour cette VM

Note infrastructure est prête pour accueillir l’application Mayan. Dans cette partie on va entamer le déploiement de l’application.

Accédez avec ssh via la VM bastion à la VM VM3.

Sur cette VM créez le script cbdms-data-node.sh qui va mettre en place les composants backend de notre application.

#!/usr/bin/env bash
# $1: PRIVATE-SUBNET-3 cidr
# $2: PRIVATE-SUBNET-4 cidr
# $3: VM03 private ip
# $4: VM04 private ip
# $5: PrivateLB dns
# Install Postgres
sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add -
apt update
apt -yq install postgresql postgresql-plperl-15
# Configure Postgres for Mayan
sudo -i -u postgres bash <<EOF
psql -c "create user mayanuser with password 'mayandbpass';"
psql -c "create database mayan with owner = mayanuser;"
EOF
# Configure Postgres for access
PG_CONF_LOCATION=/etc/$(pg_lsclusters -h | awk '{print $6}' | sed 's,\(/var/lib/\)\(.*\),\2,')/postgresql.conf
PG_HBA_LOCATION=/etc/$(pg_lsclusters -h | awk '{print $6}' | sed 's,\(/var/lib/\)\(.*\),\2,')/pg_hba.conf
sed -i "s/#\(listen_addresses = \)'localhost'/\1'*'/" $PG_CONF_LOCATION
sed -i "s,\(# Database administrative login by Unix domain socket\),\1\nhost all             bucardo         $1             trust\nhost    all             bucardo         $2             trust\n," $PG_HBA_LOCATION
echo 'host    all             all             `0.0.0.0/0`           md5' >> $PG_HBA_LOCATION
echo "host    mayan           mayanuser       $1            md5" >> $PG_HBA_LOCATION
echo "host    mayan           mayanuser       $2            md5" >> $PG_HBA_LOCATION
systemctl restart postgresql
# Add a Bucardo user to Postgres
sudo -i -u postgres bash <<EOF
psql -c "create user bucardo with superuser password 'bucardopassword';"
EOF
# Set up a password file for Postgres
echo "$3:5432:bucardo:bucardo:bucardopassword" >> ~/.pgpass
echo "$3:5432:mayan:mayanuser:mayandbpass" >> ~/.pgpass
echo "$4:5432:mayan:mayanuser:mayandbpass" >> ~/.pgpass
echo "$5:5432:mayan:mayanuser:mayandbpass" >> ~/.pgpass
#echo "10.0.3.141:5432:mayan:mayanuser:mayandbpass" >> ~/.pgpass
chmod 0600 ~/.pgpass

Exécutez le script

chmod +x cbdms-data-node.sh
./cbdms-data-node.sh <PRIVATE-SUBNET-3 cidr> <PRIVATE-SUBNET-4 cidr> <VM3 private ip> <VM4 private ip> <PrivateLB dns>

Refaite les étapes 1-3 pour la VM VM4
Mettez en place la réplication, en se connectant à nouveau sur la VM VM3

Créez le script cbdms-data-node-afterward.sh avec le contenu suivant :

# $1 VM3 private ip
# $2 VM4 private ip
# Create a Bucardo database
sudo -i -u postgres bash <<EOF
psql -c "create database bucardo with owner = bucardo;"
EOF
# Provide the Bucardo configuration file
cat > ~/.bucardorc <<EOF
dbhost=$1
dbname=bucardo
dbport=5432
dbuser=bucardo
EOF
# Clone the database contents from vm db after the Mayan deployment
pg_dump -U bucardo -h $1 -d mayan | psql -U bucardo -h $2 -d mayan
# Install Bucardo
apt install -yq bucardo
# Run the Bucardo setup steps
bucardo install --batch
bucardo add db mayandb1 dbhost="$1" dbport="5432" dbname="mayan" dbuser="bucardo"
bucardo add db mayandb2 dbhost="$2" dbport="5432" dbname="mayan" dbuser="bucardo"
bucardo add all tables db=mayandb1 --relgroup=mayanrelgroup
bucardo add dbgroup mayandbgroup mayandb1:source mayandb2:source
bucardo add sync mayandbsync dbs=mayandbgroup conflict_strategy=bucardo_latest relgroup=mayanrelgroup
# Start Bucardo
bucardo restart

Exécutez le script

chmod +x data-node-afterward.sh
data-node-afterward.sh <VM3 private ip> <VM4 private ip>

Enregistrez les VM VM3 et VM4 sur le load balancer interne PrivateLB
Accédez avec ssh via la VM bastion à la VM VM1.

Sur cette VM créez le fichiers cbdms-app.conf dans le répertoire /root avec le contenu suivant :

upstream backend {
   server localhost:8080;
}

server {
   listen 80;
   server_name <DOMAIN_NAME>;

   client_max_body_size 6048M;

   location / {
      proxy_pass http://backend;
   }
}

Sur cette VM créez le script cbdms-app-node.sh qui va mettre en place les composants frontend de notre application.

#!/usr/bin/env bash
# $1: InternetLB dns
# $2: PrivateLB dns
DOMAIN=$1
DBHOST=$2
# Install Docker and Docker Compose
apt install -yq ca-certificates curl gnupg lsb-release
mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null
apt update
apt install -yq docker-ce docker-ce-cli containerd.io docker-compose-plugin
# Download the Mayan Docker Compose files
mkdir ~/mayan-docker
cd ~/mayan-docker
curl https://gitlab.com/mayan-edms/mayan-edms/-/raw/master/docker/docker-compose.yml -O
curl https://gitlab.com/mayan-edms/mayan-edms/-/raw/master/docker/.env -O
# Adjust the Mayan configuration
sed -i '/MAYAN_PIP_INSTALLS/d' .env
sed -i '/MAYAN_DOCUMENTS_STORAGE_BACKEND/d' .env
sed -i '/MAYAN_DOCUMENTS_STORAGE_BACKEND_ARGUMENTS/d' .env
# Decouple Mayan from Postgres
sed -i "s/# \(MAYAN_DATABASE_HOST=\)/\1\"$DBHOST\"/" .env
sed -i 's/# \(MAYAN_DATABASE_NAME=\)/\1"mayan"/' .env
sed -i 's/# \(MAYAN_DATABASE_PASSWORD=\)/\1"mayandbpass"/' .env
sed -i 's/# \(MAYAN_DATABASE_USER=\)/\1"mayanuser"/' .env
sed -i 's/,postgresql//' .env
sed -i 's/postgresql:5432 //' .env
sed -i 's/^# MAYAN_FRONTEND_HTTP_PORT=80$/MAYAN_FRONTEND_HTTP_PORT=8080/' .env
# Start up Mayan
docker compose --project-name mayan up --detach
# Install and configure NGINX
mkdir -p /etc/nginx/sites-available
cp /root/cbdms-app.conf /etc/nginx/sites-available/cbdms-app.conf
apt install -yq nginx
sed -i "s/<DOMAIN_NAME>/$DOMAIN/" /etc/nginx/sites-available/cbdms-app.conf
ln -s /etc/nginx/sites-available/cbdms-app.conf /etc/nginx/sites-enabled/
rm /etc/nginx/sites-enabled/default
systemctl restart nginx
# Apply the services
systemctl daemon-reload
systemctl restart nginx

Exécutez le script

chmod +x cbdms-app-node.sh
./cbdms-app-node.sh <InternetLB dns> <PrivateLB dns>

Répétez les étapes 9 à 12 sur la VM VM2
Enregistrez les VM VM1 et VM2 sur le load balancer InternetLB
Accédez à votre application via le nom DNS du load balancer InternetLB