Aller au contenu principal

mtls

Configuration et mise en place du certificat mTLS pour la plateforme OneEntry en utilisant des tokens et mTLS, ainsi que le déploiement de l'application sur un serveur avec Nginx, Docker et GitLab

Partie 1 : Mise en place de mTLS​

Protection de l'API​

  1. Utilisation d'un Token : Générez un token dans les paramètres de OneEntry et ajoutez-le aux en-têtes de la requête avec le paramètre 'x-app-token', où la valeur est le token.
  2. Utilisation de mTLS : Activez l'option mTLS dans votre tableau de bord OneEntry et générez le certificat dans les paramètres de OneEntry.

Mise en place du certificat​

  1. Dans votre tableau de bord, allez dans l'onglet 'Accès' et passez de token à mTLS.
  2. Générez un nouveau certificat dans OneEntry ('Paramètres' -> 'Certificats d'application' -> 'Créer un nouveau certificat').
  3. Téléchargez-le sur votre ordinateur et extrayez-le dans le dossier 'cert' à la racine de votre projet.

Mise en place de l'environnement local (en utilisant ReactJS comme exemple)​

  1. Téléchargez le fichier setupProxy.js et enregistrez-le dans le dossier 'src'.
  2. Modifiez le paramètre 'target', en spécifiant l'adresse de votre projet.
  3. Installez le package 'http-proxy-middleware' : 'npm install http-proxy-middleware'.
  4. Démarrez l'application.

Partie 2 : Configuration du serveur​

Préparation du serveur​

  1. Mettez à jour les informations du dépôt : `apt update`.
  2. Ajoutez le dépôt Docker et installez les paquets : `apt install nginx certbot docker-ce pwgen`.

Configuration de UFW​

  1. Bloquez toutes les connexions entrantes : `ufw default deny incoming`.
  2. Autorisez toutes les connexions sortantes : `ufw default allow outgoing`.
  3. Autorisez les connexions TCP entrantes sur les ports 22, 80 et 443 : `ufw allow 22,80,443/tcp`.

Configuration de SSH​

  1. Modifiez la configuration du démon SSH : `nano /etc/ssh/sshd_config`.
  2. Réglez `PasswordAuthentication no`.
  3. Redémarrez le démon SSH : `systemctl restart ssh`.

Configuration de Nginx​

  1. Supprimez le fichier de configuration par défaut : `rm /etc/nginx/sites-available/default`
  2. Créez un nouveau fichier de configuration : `nano /etc/nginx/sites-available/my_app`.
  3. Téléchargez et modifiez la configuration Nginx depuis OneEntry, en remplaçant "your_domain.com" par votre domaine.
  4. Ensuite, exécutez la commande : ‘ln -s /etc/nginx/sites-available/my_app /etc/nginx/sites-enabled', en remplaçant "my_app" par le nom de votre fichier de configuration.
  5. Émettez des certificats SSL en utilisant Certbot : `certbot certonly --webroot -w /var/www/html -d your_domain`
  6. Vérifiez le renouvellement automatique des certificats : `certbot renew --dry-run`.
  7. Modifiez la tâche cron de Certbot pour recharger automatiquement la configuration de Nginx après l'émission des certificats : ‘nano /etc/cron.d/certbot', en remplaçant la dernière ligne par : `echo "0 */12 * * * root certbot -q renew && nginx -s reload" > /etc/cron.d/certbot`
  8. Décommentez les lignes dans le fichier de configuration 'nano /etc/nginx/sites-available/my_app' (où 'my_app' est le nom de votre fichier de configuration).
  9. Vérifiez la configuration de Nginx : `nginx -t`
  10. Rechargez Nginx après chaque modification : `nginx -s reload`.

Partie 3 : Déploiement de l'application avec GitLab et GitHub​

GitHub

Création d'un nouvel utilisateur pour GitHub Runner​

  1. Générez un mot de passe : 'pwgen -s 15 1'
  2. Créez un nouvel utilisateur : 'useradd -m github-runner'
  3. Définissez un mot de passe pour celui-ci : 'passwd github-runner'
  4. Ajoutez le nouvel utilisateur aux groupes : 'usermod -aG docker github-runner' et 'usermod -aG sudo github-runner'.
  5. Changez le shell pour l'utilisateur GitHub Runner : 'chsh -s /bin/bash github-runner'
  6. Passez à l'utilisateur nouvellement créé : 'sudo su - gitlab-runner'.

Configuration de GitHub Runner​

  1. Créez un GitHub Runner : allez dans les paramètres de votre dépôt, cliquez sur 'Actions' et sélectionnez 'Runners', puis cliquez sur 'Nouveau runner auto-hébergé'.
  2. Suivez les instructions dans le bloc 'Télécharger' et la première commande dans le bloc 'Configurer'.
  3. Ajoutez le Runner au démarrage automatique du système : 'sudo ./svc.sh install'. Vous devrez entrer le mot de passe généré précédemment.
  4. Démarrez le Runner : 'sudo ./svc.sh start'.
  5. Allez dans la section 'Actions', cliquez sur 'Runners', et assurez-vous que le 'Runner' est en cours d'exécution.
  6. Revenez à l'utilisateur 'root'.
  7. Créez un répertoire de travail : 'mkdir -p /var/apps/frontend'
  8. Définissez les permissions pour l'utilisateur 'github-runner' : 'chown -R github-runner:docker /var/apps/frontend'.

Configuration des variables d'environnement dans GitHub​

  1. Créez les variables `DOMAIN`, `MTLS_USER_CERT`, et `MTLS_USER_KEY` dans votre dépôt GitHub ('Paramètres' -> 'Secrets et Variables').
  2. Générez un certificat dans OneEntry, ajoutez le certificat et la clé aux variables. Dans la variable `DOMAIN`, spécifiez l'adresse de votre projet sans https.
  3. Téléchargez le fichier docker-compose.yml et deux archives .github et .docker.
  4. Placez docker-compose.yml, .github.zip, et .docker.zip dans le dossier racine de votre projet et extrayez les archives (vous pouvez supprimer les archives après extraction).
  5. Exécutez la commande de push dans votre projet.
  6. Vérifiez le processus dans l'onglet 'Actions'.
  7. Vérifiez l'accessibilité de l'application dans le navigateur.
GitLab

Enregistrement de GitLab Runner​

  1. Spécifiez les tags 'docker, frontend'.
  2. Allez dans 'Paramètres -> CI/CD -> Runners' et cliquez sur le bouton 'Nouveau runner de projet'.
  3. Accédez au répertoire créé : `cd /var/apps/gitlab-runner`.
  4. Exécutez la commande pour démarrer le processus d'enregistrement : `docker compose run runner register`.
  5. Entrez l'URL de GitLab, par exemple, https://gitlab.com/.
  6. Obtenez le token d'enregistrement depuis GitLab (dans la section 'Runners' du projet) et collez-le dans le terminal.
  7. Spécifiez l'exécuteur comme 'docker'.
  8. Spécifiez l'image par défaut comme docker:20.10.16.

Configuration des variables d'environnement dans GitLab​

  1. Créez les variables `DOMAIN`, `MTLS_USER_CERT`, et `MTLS_USER_KEY` dans votre dépôt GitLab ('Paramètres' -> 'CI/CD' -> 'Variables').
  2. Générez un certificat dans OneEntry, ajoutez le certificat et la clé aux variables, et spécifiez l'adresse de votre projet sans https dans la variable `DOMAIN`.
  3. Téléchargez les fichiers docker-compose.yml, .gitlab-ci.yml, et l'archive .docker, placez les fichiers à la racine de votre projet, et décompressez les archives (vous pouvez supprimer les archives après décompression).

Préparation de la configuration de GitLab Runner (exécuteur Docker)​

  1. Créez les répertoires nécessaires : `mkdir -p /var/apps/gitlab-runner/volumes/etc/gitlab-runner`
  2. Exécutez la commande : `cat \ /var/apps/gitlab-runner/docker-compose.yamlversion: '3' services: runner: image: 'gitlab/gitlab-runner:v16.2.0' restart: always container_name: 'gitlab-runner' privileged: true volumes: - './volumes/etc/gitlab-runner:/etc/gitlab-runner' - '/var/run/docker.sock:/var/run/docker.sock' EOT`

Configuration de GitLab Runner​

  1. Modifiez le fichier de configuration : `nano volumes/etc/gitlab-runner/config.toml`.
  2. Réglez le paramètre `priviledged` sur `true` pour activer Docker-in-Docker.
  3. Changez la valeur de `volumes` en `['/var/run/docker.sock:/var/run/docker.sock', '/cache']` pour que Docker fonctionne correctement.
  4. Ajoutez `user = 'gitlab-runner'` au début du fichier pour exécuter le Runner en tant que cet utilisateur.
  5. Enregistrez les modifications et quittez l'éditeur.
  6. Redémarrez le Runner : 'systemctl restart gitlab-runner'.

Activation et vérification de GitLab Runner​

  1. Exécutez la commande `docker compose up -d` pour démarrer le Runner.
  2. Allez sur GitLab et vérifiez que le Runner est actif et en cours d'exécution (vous devriez voir son statut dans la section 'Runners' du projet).

Mise en place d'un Runner supplémentaire sur l'hôte (exécuteur shell)​

  1. Suivez les Instructions pour installer un Runner supplémentaire qui s'exécute directement sur l'hôte (pas dans Docker).
  2. Définissez des tags pour le Runner : 'shell, frontend'.

Permissions du Runner​

  1. Ajoutez un nouvel utilisateur au groupe : 'usermod -aG docker gitlab-runner'
  2. Si vous devez changer le propriétaire et les groupes pour un fichier ou un répertoire : 'chown -R gitlab-runner:docker /var/apps/frontend'

Configuration finale et tests​

  1. Assurez-vous que tous les Runners sont correctement configurés et prêts à l'emploi.
  2. Exécutez la commande de push dans votre projet.
  3. Vérifiez l'avancement dans 'Build' -> 'Pipelines'.
  4. Vérifiez la disponibilité de l'application dans le navigateur.

Conclusion​

Suivez ces étapes pour une configuration et un déploiement réussis de votre application avec OneEntry. Bonne chance avec le développement !