Configurer des groupes et des politiques

Vous pourrez créer des groupes et des politiques une fois que vous aurez terminé les étapes décrites à la section Intégrer HashiCorp Cloud Platform Vault à Okta.

Configurer des groupes dans Okta

Créez un groupe pour chaque type d'utilisateur (administrateurs et développeurs, par exemple) qui nécessite un accès à HCP Vault.

1. Pour chaque groupe provenant d'Okta que vous souhaitez créer, suivez les étapes de la section Créer un groupe. Assurez-vous que chaque nom de groupe utilise le préfixe okta-group-vault. Par exemple, okta-group-vault-admins pour les utilisateurs administrateurs et okta-group-vault-developer pour les utilisateurs développeurs.
2. Affectez manuellement des personnes à un groupe (ou Affectez en masse des personnes à un groupe) pour accorder des niveaux accès granulaires aux utilisateurs.

Configurez des politiques dans HCP Vault

Créez une politique pour chacun des groupes d'utilisateurs créés dans la section précédente. Les politiques garantissent que différents profils et capacités d'utilisateurs peuvent accéder aux clés secrètes qui sont stockées dans HCP Vault. Consultez Introduction aux politiques pour plus d'informations. Il existe deux façons de configurer les politiques : Utiliser une commande de l'interface de ligne de commande ou Utiliser l'API.

Utiliser une commande de l'interface de ligne de commande

1. Exécutez cette commande pour créer un fichier de politique nommé vault-policy-developer-read.hcl :

   #!/bin/bash 
   tee vault-policy-developer-read.hcl <<EOF
   # Read permission on the k/v secrets
   path "/secret/*" {
   	capabilities = ["read", "list"]
   }
   EOF

2. Exécutez cette commande pour créer une politique nommée vault-policy-developer-read. La politique utilise le fichier que vous avez créé lors de l'étape précédente :

   #!/bin/bash
   vault policy write vault-policy-developer-read vault-policy-developer-read.hcl
   

3. Exécutez cette commande pour créer un fichier de politique nommé vault-policy-admin.hcl :

   #!/bin/bash 
   tee vault-policy-admin.hcl <<EOF
   # Admin policy
   path "*" {
   	capabilities =
   ["sudo","read","create","update","delete","list","patch"]
   }
   EOF

4. Exécutez cette commande pour créer une politique nommée vault-policy-admin. La politique utilise le fichier que vous avez créé lors de l'étape précédente :

   #!/bin/bash
   vault policy write vault-policy-admin vault-policy-admin.hcl
   

5. Exécutez cette commande pour afficher les politiques que vous venez de créer, ainsi que les politiques HCP Vault par défaut :

   #!/bin/bash
   vault policy list

Utiliser l'API

Effectuez ces étapes dans HCP Vault Dedicated ou HCP Vault.

HCP Vault Dedicated

1. Envoyez une requête API qui contient une politique vault-policy-developer-read au format JSON :

   #!/bin/bash
   tee vault-policy-developer-read.json <<EOF
   {
   "policy": "path \"/secret/*\" {\n\tcapabilities = [\"read\", \"list\"]\n}\n"
   }
   EOF		

2. Créez une politique nommée vault-policy-developer-read qui utilise la politique définie dans vault-policy-developer-read.json :

   curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	--header "X-Vault-Namespace: $VAULT_NAMESPACE" \
   	--request PUT \
   	--data @vault-policy-developer-read.json \
   	$VAULT_ADDR/v1/sys/policies/acl/vault-policy-developer-read	

3. Créez une requête API qui contient une politique vault-policy-admin au format JSON :

   #!/bin/bash
   tee vault-policy-admin.json <<EOF
   {
   "policy": "path \"/secret/*\" {\n\tcapabilities = [\"read\", \"list\", \"sudo\", \"create\", \"update\", \"delete\", 
   \"patch\"]\n}\n"
   }
   EOF

4. Créez une politique nommée vault-policy-admin qui utilise la politique définie dans vault-policy-admin.json :

   curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	--header "X-Vault-Namespace: $VAULT_NAMESPACE" \
   	--request PUT \
   	--data @vault-policy-admin.json \
   	$VAULT_ADDR/v1/sys/policies/acl/vault-policy-admin	

5. Exécutez cette commande pour afficher les politiques que vous venez de créer, ainsi que les politiques dédiées par défaut dans HCP Vault :

   curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	--header "X-Vault-Namespace: $VAULT_NAMESPACE" \
   	$VAULT_ADDR/v1/sys/policy | jq '.data | .policies'
   

HCP Vault

1. Envoyez une requête API qui contient une politique vault-policy-developer-read au format JSON :

   #!/bin/bash
   tee vault-policy-developer-read.json <<EOF
   {
   "policy": "path \"/secret/*\" {\n\tcapabilities = [\"read\", \"list\"]\n}\n"
   }
   EOF			

2. Créez une politique nommée vault-policy-developer-read qui utilise la politique définie dans vault-policy-developer-read.json :

   curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	--request PUT \
   	--data @vault-policy-developer-read.json \
   	$VAULT_ADDR/v1/sys/policies/acl/vault-policy-developer-read

3. Créez une requête API qui contient une politique vault-policy-admin au format JSON :

   #!/bin/bash
   tee vault-policy-admin.json <<EOF
   {
   "policy": "path \"/secret/*\" {\n\tcapabilities = [\"read\", \"list\", \"sudo\", \"create\", \"update\", \"delete\", \"patch\"]\n}\n"
   }
   EOF		

4. Créez une politique nommée vault-policy-admin qui utilise la politique définie dans vault-policy-admin.json :

   curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	--request PUT \
   	--data @vault-policy-admin.json \
   	$VAULT_ADDR/v1/sys/policies/acl/vault-policy-admin

5. Exécutez cette commande pour afficher les politiques que vous venez de créer, ainsi que les politiques HCP Vault par défaut :

   curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	$VAULT_ADDR/v1/sys/policy | jq '.data | .policies'

Configurer des groupes dans HCP Vault

Créez des groupes dans HCP Vault qui correspondent aux groupes que vous avez créés dans Okta. Il existe deux façons de configurer les politiques : Utiliser une commande de l'interface de ligne de commande ou Utiliser l'API.

Utiliser une commande de l'interface de ligne de commande

1. Exécutez cette commande pour créer un rôle appelé vault-role-okta-group-vault-developer. Cette action affecte la politique par défaut au rôle suivant :

   #!/bin/bash
   vault write auth/oidc/role/vault-role-okta-group-vault-developer \
   	bound_audiences="$OKTA_CLIENT_ID" \
   allowed_redirect_uris="$VAULT_ADDR/ui/vault/auth/oidc/oidc/callback" \
   	allowed_redirect_uris="http://localhost:8250/oidc/callback" \
   	user_claim="sub" \
   	token_policies="default" \
   	oidc_scopes="groups" \
   	groups_claim="groups"
   

2. Exécutez cette commande pour créer un groupe appelé okta-group-vault-developer et affectez-le à la politique vault-policy-developer-read policy :

   #!/bin/bash
   vault write identity/group name="okta-group-vault-developer" type="external" \
   	policies="vault-policy-developer-read" \
   	metadata=responsibility="okta-group-vault-developer"

3. Exécutez cette commande pour créer une variable appelée GROUP_ID. La variable contient l'ID du groupe que vous venez de créer.

   #!/bin/bash
   GROUP_ID=$(vault read -field=id 
   identity/group/name/okta-group-vault-developer)	

4. Exécutez cette commande pour créer une variable OIDC_AUTH_ACCESSOR pour la méthode d'authentification OIDC :

   #!/bin/bash
   OIDC_AUTH_ACCESSOR=$(vault auth list -format=json  | jq -r '."oidc/".accessor')

5. Exécutez cette commande pour créer un alias de groupe appelé okta-group-vault-developer. L'alias connecte la méthode d'authentification OIDC et le groupe que vous avez créé précédemment à la politique vault-policy-developer-read.

   #!/bin/bash
   vault write identity/group-alias name="okta-group-vault-developer" \
   	mount_accessor="$OIDC_AUTH_ACCESSOR" \
   	canonical_id="$GROUP_ID"

6. Exécutez cette commande, puis connectez-vous en tant que développeur avec le rôle okta-group-vault-developer :

   #!/bin/bash
   vault login -method=oidc role="vault-role-okta-group-vault-developer"

   Un message de réussite et une liste de paires clé-valeur s'affichent. Le jeton qui est renvoyé utilise vault-policy-developer-read ,car okta-group-vault-developer correspond au groupe Okta affecté.

7. Déconnectez-vous d'Okta.
8. Exécutez cette commande pour créer un rôle appelé vault-role-okta-group-vault-admins :

   #!/bin/bash
   vault write auth/oidc/role/vault-role-okta-group-vault-admins \
   	bound_audiences="$OKTA_CLIENT_ID" \
   	allowed_redirect_uris="$VAULT_ADDR/ui/vault/auth/oidc/oidc/callback" \
   	allowed_redirect_uris="http://localhost:8250/oidc/callback" \
   	user_claim="sub" \
   	token_policies="default" \
   	oidc_scopes="groups" \
   	groups_claim="groups"

9. Exécutez cette commande pour créer un groupe okta-group-vault-admins qui utilise la politique vault-policy-admin :

   #!/bin/bash
   vault write identity/group name="okta-group-vault-admins" type="external" \
   	policies="vault-policy-admin" \
   	metadata=responsibility="okta-group-vault-admins"		

10. Exécutez cette commande pour créer une variable GROUP_ID qui stocke l'ID de groupe okta-group-vault-admins :

    #!/bin/bash
    	GROUP_ID=$(vault read -field=id identity/group/name/okta-group-vault-admins)		

11. Exécutez cette commande pour créer une variable OIDC_AUTH_ACCESSOR pour la méthode d'authentification OIDC :

    #!/bin/bash
    OIDC_AUTH_ACCESSOR=$(vault auth list -format=json  | jq -r '."oidc/".accessor')

12. Exécutez cette commande pour créer un alias de groupe appelé okta-group-vault-admins. L'alias connecte la méthode d'authentification OIDC et le groupe que vous avez créé précédemment à la politique vault-policy-admin.

    #!/bin/bash
    vault write identity/group-alias name="okta-group-vault-admins" \
    	mount_accessor="$OIDC_AUTH_ACCESSOR" \
    	canonical_id="$GROUP_ID"

13. Exécutez cette commande, puis connectez-vous avec le rôle okta-group-vault-admins :

    #!/bin/bash
    vault login -method=oidc role="vault-role-okta-group-vault-admins"

    Un message de réussite et une liste de paires clé-valeur s'affichent. Le jeton qui est renvoyé utilise vault-policy-admin car okta-group-vault-admins correspond au groupe Okta affecté.

Utiliser l'API

Effectuez ces étapes dans HCP Vault Dedicated ou HCP Vault.

HCP Vault Dedicated

1. Envoyez une requête pour le rôle okta-group-vault-developer :

   #!/bin/bash
   tee vault-role-okta-group-vault-developer.json <<EOF
   {
   	"bound_audiences": "$OKTA_CLIENT_ID",
   	"allowed_redirect_uris": [
   	"$VAULT_ADDR/ui/vault/auth/oidc/oidc/callback",
   	"http://localhost:8250/oidc/callback"
   	],
   	"user_claim": "sub",
   	"token_policies": ["default"],
   	"oidc_scopes": "groups",
   	"groups_claim": "groups"
   }
   EOF		

2. Envoyez une requête pour créer un rôle appelé vault-role-okta-group-vault-developer :

   curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	--header "X-Vault-Namespace: $VAULT_NAMESPACE" \
   	--request POST \
   	--data @vault-role-okta-group-vault-developer.json \
   $VAULT_ADDR/v1/auth/oidc/role/vault-role-okta-group-vault-developer	

3. Envoyez une requête qui affecte la politique vault-policy-developer-read au groupe okta-group-vault-developer :

   #!/bin/bash
   tee okta-group-vault-developer.json <<EOF
   {
   	"name": "okta-group-vault-developer",
   	"policies": ["vault-policy-developer-read"],
   	"type": "external",
   	"metadata": {
   	"responsibility": "okta-group-vault-developer"
   	}
   }
   EOF		

4. Envoyez une requête pour créer un groupe qui contient la définition de groupe okta-group-vault-developer.json :

   curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	--header "X-Vault-Namespace: $VAULT_NAMESPACE" \
   	--request POST 
   	--data @okta-group-vault-developer.json \
   	$VAULT_ADDR/v1/identity/group | jq			

5. Envoyez une requête pour créer une variable GROUP_ID pour le groupe okta-group-vault-developer :

   #!/bin/bash
   GROUP_ID=$(curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	--header "X-Vault-Namespace: $VAULT_NAMESPACE" \
   	--request GET \
   	$VAULT_ADDR/v1/identity/group/name/okta-group-vault-developer | jq '.data | .id' -r)

6. Envoyez une requête pour créer une variable OIDC_AUTH_ACCESSOR pour la méthode d'authentification OIDC :

   #!/bin/bash
   OIDC_AUTH_ACCESSOR=$(curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	--header "X-Vault-Namespace: $VAULT_NAMESPACE" \
   	$VAULT_ADDR/v1/sys/auth | jq '.data | ."oidc/".accessor' -r)

7. Utilisez cette commande pour créer un alias de groupe appelé okta-group-vault-developer :

   #!/bin/bash
   tee alias-okta-group-vault-developer.json <<EOF
   {
   	"canonical_id": "$GROUP_ID",
   	"mount_accessor": "$OIDC_AUTH_ACCESSOR",
   	"name": "okta-group-vault-developer"
   }
   EOF		

8. Envoyez une requête qui partage l'alias okta-group-vault-developer avec HCP Vault :

   #!/bin/bash
   curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	--header "X-Vault-Namespace: $VAULT_NAMESPACE" \
   	--request POST -s \
   	--data @alias-okta-group-vault-developer.json \
   	$VAULT_ADDR/v1/identity/group-alias | jq
   

9. Envoyez cette requête, puis connectez-vous en tant que développeur avec le rôle okta-group-vault-developer :

   #!/bin/bash
   vault login -method=oidc role="vault-role-okta-group-vault-developer"

   Un message de réussite et une liste de paires clé-valeur s'affichent. Le jeton qui est renvoyé utilise vault-policy-developer-read ,car okta-group-vault-developer correspond au groupe Okta affecté.

10. Déconnectez-vous d'Okta.
11. Envoyez une requête pour le rôle okta-group-vault-admins :

    #!/bin/bash
    tee vault-role-okta-group-vault-admins.json << EOF
    {
    	"bound_audiences": "$OKTA_CLIENT_ID",
    	"allowed_redirect_uris": [
    	"$VAULT_ADDR/ui/vault/auth/oidc/oidc/callback",
    	"http://localhost:8250/oidc/callback"
    	],
    	"user_claim": "sub",
    	"token_policies": ["default"],
    	"oidc_scopes": "groups",
    	"groups_claim": "groups"
    }
    EOF			

12. Envoyez une requête pour créer un rôle appelé vault-role-okta-group-vault-admins :

    curl --header "X-Vault-Token: $VAULT_TOKEN" \
    	--header "X-Vault-Namespace: $VAULT_NAMESPACE" \
    	--request POST \
    	--data @vault-role-okta-group-vault-admins.json \
    	$VAULT_ADDR/v1/auth/oidc/role/vault-role-okta-group-vault-admins

13. Envoyez une requête qui définit le groupe okta-group-vault-admins affecté à la politique vault-policy-admin :

    #!/bin/bash
    tee okta-group-vault-admins.json <<EOF
    {
    	"name": "okta-group-vault-admins",
    	"policies": ["vault-policy-admin"],
    	"type": "external",
    	"metadata": {
    		"responsibility": "okta-group-vault-admins"	
    	}
    }
    EOF		

14. Envoyez une requête qui crée un groupe avec la définition du groupe dans okta-group-vault-admins.json :

    curl --header "X-Vault-Token: $VAULT_TOKEN" \
    	--header "X-Vault-Namespace: $VAULT_NAMESPACE" \
    	--request POST \
    	--data @okta-group-vault-admins.json
    	$VAULT_ADDR/v1/identity/group | jq

15. Envoyez une requête pour créer une variable GROUP_ID qui contient l'ID de groupe okta-group-vault-admins :

    #!/bin/bash
    GROUP_ID=$(curl --header "X-Vault-Token: $VAULT_TOKEN" \
    	--header "X-Vault-Namespace: $VAULT_NAMESPACE" \
    	--request GET \
    	$VAULT_ADDR/v1/identity/group/name/okta-group-vault-admins | jq '.data | .id' -r)

16. Envoyez une requête pour créer une variable OIDC_AUTH_ACCESSOR pour la méthode d'authentification OIDC :

    #!/bin/bash
    OIDC_AUTH_ACCESSOR=$(curl --header "X-Vault-Token: $VAULT_TOKEN" \
    	--header "X-Vault-Namespace: $VAULT_NAMESPACE" \
    	$VAULT_ADDR/v1/sys/auth | jq '.data | ."oidc/".accessor' -r)

17. Envoyez une requête pour créer un alias okta-group-vault-admins :

    curl --header "X-Vault-Token: $VAULT_TOKEN" \
    	--header "X-Vault-Namespace: $VAULT_NAMESPACE" \
    	--request POST -s \
    	--data @alias-okta-group-vault-admins.json \
    	$VAULT_ADDR/v1/identity/group-alias | jq	

18. Envoyez cette requête, puis connectez-vous avec le rôle vault-role-okta-group-vault-admin :

    #!/bin/bash
    vault login -method=oidc role="vault-role-okta-group-vault-admins"

    Un message de réussite et une liste de paires clé-valeur s'affichent. Le jeton qui est renvoyé utilise vault-policy-admin car okta-group-vault-admins correspond au groupe Okta affecté.

HCP Vault

1. Envoyez une requête API pour le rôle okta-group-vault-developer :

   #!/bin/bash
   tee vault-role-okta-group-vault-developer.json << EOF
   {
   	"bound_audiences": "$OKTA_CLIENT_ID",
   	"allowed_redirect_uris": [
   		"$VAULT_ADDR/ui/vault/auth/oidc/oidc/callback",
   		"http://localhost:8250/oidc/callback"
   	],
   	"user_claim": "sub",
   	"token_policies": ["default"],
   	"oidc_scopes": "groups",
   	"groups_claim": "groups"
   }
   EOF			

2. Envoyez une requête pour créer un rôle appelé vault-role-okta-group-vault-developer :

   curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	--request POST \
   	--data @vault-role-okta-group-vault-developer.json \
   	$VAULT_ADDR/v1/auth/oidc/role/vault-role-okta-group-vault-developer

3. Envoyez une requête pour créer un groupe qui contient la définition de groupe okta-group-vault-developer.json :

   curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	--request POST \
   	--data @okta-group-vault-developer.json \
   	$VAULT_ADDR/v1/identity/group | jq

4. Envoyez une requête pour créer une variable GROUP_ID qui contient l'ID okta-group-vault-developer :

   #!/bin/bash
   GROUP_ID=$(curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	--request GET \
   $VAULT_ADDR/v1/identity/group/name/okta-group-vault-developer | jq '.data | .id' -r)

5. Envoyez une requête qui crée une variable OIDC_AUTH_ACCESSOR pour la méthode d'authentification OIDC :

   #!/bin/bash
   OIDC_AUTH_ACCESSOR=$(curl --header "X-Vault-Token: $VAULT_TOKEN" \
   $VAULT_ADDR/v1/sys/auth | jq '.data | ."oidc/".accessor' -r)

6. Utilisez cette commande pour créer un alias pour okta-group-vault-developer :

   #!/bin/bash
   tee alias-okta-group-vault-developer.json <<EOF
   {
   	"canonical_id": "$GROUP_ID",
   	"mount_accessor": "$OIDC_AUTH_ACCESSOR",
   	"name": "okta-group-vault-developer"
   }
   EOF	

7. Envoyez une requête pour partager l'alias okta-group-vault-developer avec HCP Vault :

   curl --header "X-Vault-Token: $VAULT_TOKEN" \
   	--request POST -s \
   	--data @alias-okta-group-vault-developer.json \
   	$VAULT_ADDR/v1/identity/group-alias | jq

8. Envoyez cette requête, puis connectez-vous avec le rôle vault-role-okta-group-vault-developer :

   #!/bin/bash
   vault login -method=oidc role="vault-role-okta-group-vault-developer"

   Un message de réussite et une liste de paires clé-valeur s'affichent. Le jeton qui est renvoyé utilise vault-policy-developer-read ,car okta-group-vault-developer correspond au groupe Okta affecté.

9. Déconnectez-vous d'Okta.
10. Envoyez une requête pour le rôle okta-group-vault-admins :

    #!/bin/bash
    tee vault-role-okta-group-vault-admins.json << EOF
    {
    	"bound_audiences": "$OKTA_CLIENT_ID",
    	"allowed_redirect_uris": [
    	"$VAULT_ADDR/ui/vault/auth/oidc/oidc/callback",
    	"http://localhost:8250/oidc/callback"
    	],
    	"user_claim": "sub",
    	"token_policies": ["default"],    "oidc_scopes": "groups",
    	"groups_claim": "groups"
    }
    EOF		

11. Envoyez une requête pour créer un rôle appelé vault-role-okta-group-vault-admins :

    curl --header "X-Vault-Token: $VAULT_TOKEN" \
    	--request POST \
    	--data @vault-role-okta-group-vault-admins.json \
    	$VAULT_ADDR/v1/auth/oidc/role/vault-role-okta-group-vault-admins

12. Envoyez une requête qui affecte la politique vault-policy-admin au groupe okta-group-vault-admins :

    #!/bin/bash
    tee okta-group-vault-admins.json <<EOF
    {
    	"name": "okta-group-vault-admins",
    	"policies": ["vault-policy-admin"],
    	"type": "external",
    	"metadata": {
    	"responsibility": "okta-group-vault-admins"
    	}
    }
    EOF			

13. Envoyez une requête pour créer un groupe qui contient la définition de groupe okta-group-vault-admins.json :

    curl --header "X-Vault-Token: $VAULT_TOKEN" \
    	--request POST \
    	--data @okta-group-vault-admins.json \
    	$VAULT_ADDR/v1/identity/group | jq

14. Envoyez une requête pour créer une variable GROUP_ID qui contient le groupe okta-group-vault-admins :

    #!/bin/bash
    GROUP_ID=$(curl --header "X-Vault-Token: $VAULT_TOKEN" \
    	--request GET \
    	$VAULT_ADDR/v1/identity/group/name/okta-group-vault-admins | jq '.data | .id' -r)

15. Envoyez une requête pour créer une variable OIDC_AUTH_ACCESSOR pour la méthode d'authentification OIDC :

    #!/bin/bash
    OIDC_AUTH_ACCESSOR=$(curl --header "X-Vault-Token: $VAULT_TOKEN" \
    	$VAULT_ADDR/v1/sys/auth | jq '.data | ."oidc/".accessor' -r)

16. Utilisez cette commande pour créer un aliasokta-group-vault-admins :

    #!/bin/bash
    tee alias-okta-group-vault-admins.json <<EOF
    {
    	"canonical_id": "$GROUP_ID",
    	"mount_accessor": "$OIDC_AUTH_ACCESSOR",
    	"name": "okta-group-vault-admins"
    }
    EOF			

17. Envoyez une requête pour partager l'alias okta-group-vault-admins avec HCP Vault :

    curl --header "X-Vault-Token: $VAULT_TOKEN" \
    	--request POST -s \
    	--data @alias-okta-group-vault-admins.json \
    	$VAULT_ADDR/v1/identity/group-alias | jq

18. Envoyez cette requête, puis connectez-vous avec le rôle vault-role-okta-group-vault-admins :

    #!/bin/bash
    vault login -method=oidc role="vault-role-okta-group-vault-admins"

    Un message de réussite et une liste de paires clé-valeur s'affichent. Le jeton qui est renvoyé utilise vault-policy-admin car okta-group-vault-admins correspond au groupe Okta affecté.

Étape suivante

Testez l'intégration