====== 1Password SCIM Bridge ======

Pour la synchronisation des utilisateurs dans 1Password, il est nécessaire d'avoir une VM avec un service SCIM. 1Password fourni le logiciel sous la forme d'une image docker : [[https://hub.docker.com/r/1password/scim|docker.io/1password/scim]]. Au moment d'écrire cet article, la dernière version est v2.9.15. La mise en place du bridge SCIM consiste à faire tourner cette image docker et l'exposer via un lien WEB.

Il faut donc :
  * Un accès à la configuration du nom de domaine
  * Un système en mesure de faire fonctionner un container (Docker / Kubernetes / Cloud). Nous utiliserons une VM Docker dans notre exemple.
  * Un accès à la configuration admin de 1Password pour créer des tokens.
  * L'accès à la configuration du pare-feu pour les ouvertures de port.

===== Création de la VM =====

Sur l'infrastructure client, il faut créer la VM, nous utiliserons un Debian dernière version, sans interface graphique et avec le minimum d'outil préinstallé. Nous y ajouterons installerons uniquement [[https://docs.docker.com/engine/install/debian/|Docker Engine]] (voir la documentation de Docker pour l'installation).

Prérequis : 
  * CPU : 1 
  * Mémoire : 2 Go
  * Stockage : 20 Go 
  * Iso : Debian 13 standard

Pré installation de la VM : 
  * Choisir "install" sans installation graphique 
  * Langue : Français 
  * Pays : France
  * Clavier : Français
  * Nom de la machine : 1Password
  * Domaine : 
  * Mettez en place de Mot de passe superutilisateur root
  * Créez un nouvel utilisateur 
  * Créez le mot de passe pour l'utilisateur
  * Partitionner les disques : Assisté - utiliser un disque entier
  * Sélectionnez le disque > tout dans une seule partition (recommandé pour les débutants)
  * Appliquez les changements sur le disque
  * Utilisez le miroir deb.debian.org
  * Désélectionnez tout les utilitaires
  * Installez le GRUB sur /dev/sda

===== Installation Docker =====
Mettre à jour l'index des paquets du système.
<code bash> 
sudo apt update
</code>

Installer les dépendances nécessaires pour télécharger et gérer les certificats.
<code bash>
sudo apt install ca-certificates curl
</code>

Créer le répertoire destiné au stockage des clés GPG si celui-ci n'existe pas encore.
<code bash>
sudo install -m 0755 -d /etc/apt/keyrings
</code>

Télécharger la clé GPG officielle de Docker et l'enregistrer dans le répertoire dédié.
<code bash>
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
</code>

Ajuster les permissions afin que la clé soit lisible par tous les utilisateurs.
<code bash>
sudo chmod a+r /etc/apt/keyrings/docker.asc 
</code>

Ajouter le dépôt officiel Docker à la liste des sources APT du système.
<code bash>
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF
</code>

Mettre à jour l'index des paquets afin de prendre en compte le nouveau dépôt Docker.
<code bash>
sudo apt update
</code>

Installer Docker Engine ainsi que les composants associés.
<code bash>
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
</code>

Vérifier que le service Docker est actif.
<code bash>
sudo systemctl status docker
</code>

Si le service n'est pas démarré, le lancer manuellement.
<code bash>
sudo systemctl start docker
</code>

Vérifier le bon fonctionnement de l'installation en exécutant le conteneur de test Hello World.
<code bash>
sudo docker run hello-world
</code>

Cette commande télécharge l'image de test hello-world puis l'exécute dans un conteneur. Un message de confirmation s'affiche lorsque l'installation est correctement réalisée.

Docker Engine est maintenant installé et prêt à être utilisé.

===== Configuration 1Password =====

==== Fichier de l'application ====

Créer un dossier 1password dans le répertoire /etc, rentrez dedans et créez un fichier docker-compose.yaml

<code bash>
mkdir /etc/1password
cd /etc/1password
nano docker-compose.yaml
</code>

Copier coller le fichier ci-dessous :

<file yaml docker-compose.yaml>
services:
  redis:
    command: --maxmemory 256mb --maxmemory-policy volatile-lru --save ""
    deploy:
      resources:
        reservations:
          cpus: "0.125"
        limits:
          memory: 512M
    healthcheck:
      test: redis-cli ping | grep PONG
    image: docker.io/redis
    restart: always
    networks: [op-scim]
    user: 999:999
  scim:
    depends_on: [redis]
    restart: always
    deploy:
      resources:
        reservations:
          cpus: "0.125"
        limits:
          memory: 512M
    environment: 
      OP_REDIS_URL: redis://redis:6379
      OP_TLS_DOMAIN: ${SCIM_TLS_DOMAIN:-}
      OP_LETSENCRYPT_EMAIL: ${SCIM_TLS_EMAIL:-admin@wcentric.com}
      OP_DEBUG: ${SCIM_DEBUG:-0}
      OP_CONFIRMATION_INTERVAL: ${SCIM_CONFIRMATION_INTERVAL:-300}
      OP_JSON_LOGS: ${SCIM_JSON_LOGS:-0}
      OP_PRETTY_LOGS: ${SCIM_PRETTY_LOGS:-0}
      OP_TRACE: ${SCIM_TRACE:-0}
      OP_PING_SERVER: ${SCIM_PING_SERVER:-0}

    image: docker.io/1password/scim:v2.9.15
    networks: [op-scim]
    ports:
      - "${SCIM_PORT:-443}:8443"
    secrets:
      - source: credentials
        target: /home/opuser/.op/scimsession
        uid: "999"
        gid: "999"
        mode: 0440
    user: 999:999
networks:
  op-scim:
    name: op-scim
secrets:
  credentials:
    file: ./scimsession
    name: credentials
</file>

Sur 1password portail admin, accéder a votre entreprise gérée puis dans intégration> approvisionnement automatique> sélectionnez Entra Azure AD> télécharger le fichier scimsession et enregistrez votre bearer token.

==== Configuration de l'application ====

Dans le dossier 1password de la machine créer le fichier scimsession et y copier le contenu du fichier scimsession récupéré sur le centre admin 1password. 
<code bash>
nano scimsession
</code>

Il faut ensuite créer les paramètres de configuration. Les paramètres de configuration sont à mettre dans un fichier ''.env''. Le format est le nom du paramètre ''='' valeur, sans espace entre le nom du paramètre, le signe ''='' et la valeur. Il peut y avoir des lignes vides et des commentaires commençant par ''#''.

<code bash> 
nano .env
</code>

Exemple de fichier ''.env'' :
<code bash>
# URL d'accès extérieur à la VM
SCIM_TLS_DOMAIN=mysync.scim.exemple.com

# Adresse email déclaré pour la création du certificat
SCIM_TLS_EMAIL=admin@exemple.com

# Port qui sera utilisé pour recevoir les requêtes
SCIM_PORT=443
</code>

===== Redirection de port =====

La VM doit être accessible de l'extérieur. Elle doit pouvoir être contacté par le service qui va faire la synchronisation (Entra / Okta / etc..). Cet accès doit obligatoirement être sur le port 443/tcp (port HTTPS).

Sur le routeur avec une IP publique, redirigez le port TCP 443 de l'IP publique en TCP vers le port 443 de l'IP sur le réseau interne de la VM. Voir la documentation du pare-feu utilisé pour réaliser cette opération.

Le but final est d'héberger une "api web". Il faut donc aussi configurer un nom de domaine (celui de la variable ''SCIM_TLS_DOMAIN'' configuré précédemment) qui pointe vers l'adresse IP publique du routeur.

Exemple, nous avons une IP publique ''203.0.113.12'' et nom de domaine ''mysync.scim.exemple.com''.
<code>
mysync.scim.exemple.com.    A    203.0.113.12
</code>

===== Contrôle de l'application =====

Une fois le contenu du fichier ajouter vous pouvez lancer le docker compose. 
<code bash>
docker compose up -d 
</code>

<note>Alternativement, vous pouvez utiliser la commande ''docker compose up'' sans le ''-d'' pour voir les logs en temps réel sur le lancement de l'application.</note>

Il est possible d'afficher directement les logs lorsque docker compose est en cours.
<code bash> 
docker compose logs
</code>

Pour arrêter et supprimer totalement les dockers en cours. 
<code bash>
docker compose down
</code>

Pour afficher les docker en cours d'utilisation. 
<code bash>
docker ps
</code>

Pour vérifier les paramètres du container.
<code bash>
docker inspect dockerid
</code>

===== Vérification du fonctionnement =====

Pour vérifier le bon fonctionnement de la VM, vous devez avoir :
  * Le nom de domaine externe
  * Une machine hors réseau pour lancer le test
  * Le Bearer Token donné lors de la configuration de la synchronisation SCIM sur 1Password.

Pour des fins d'exemple, nous aurons en domaine ''mysync.scim.exemple.com'' et en token ''API_EXEMPLE_TOKEN''.

Commande de test avec curl sous Linux :
<code bash>
curl --silent --show-error --request GET --header "Accept: application/json" --header "Authorization: Bearer API_EXEMPLE_TOKEN" https://mysync.scim.exemple.com/health
</code>

Commande de test avec Invoke-WebRequest sous Windows PowerShell :
<code powershell>
Invoke-WebRequest -Headers @{'Accept'='application/json'; 'Authorization'='Bearer API_EXEMPLE_TOKEN'} -Method GET -UseBasicParsing -Uri 'https://mysync.scim.exemple.com/health'
</code>

Si tout fonctionne, vous pouvez activer la synchronisation aussi bien sur 1Password que sur votre fournisseur SCIM.