Suivez ce guide pour créer un projet OpenAI et mettre en place des contrôles d’accès réutilisables. Vous définirez les actions qu’une identité peut effectuer grâce à un rôle de projet, réunirez les identités dans un groupe de l’organisation et associerez ce groupe au projet.
À l’issue de ces étapes, vous disposerez d’une configuration réutilisable qui permet de :
- Créer un projet OpenAI pour une application.
- Définir un rôle de projet selon le principe du moindre privilège.
- Créer un groupe dans l’organisation pour les identités qui ont besoin d’accéder au projet.
- Donner au groupe accès au projet en lui attribuant ce rôle.
- Ajouter au groupe un utilisateur existant de l’organisation.
Avant de commencer
Terminez la configuration du fournisseur Terraform, puis exportez une clé API d’administration dans la variable d’environnement OPENAI_ADMIN_KEY. Vous aurez aussi besoin de l’identifiant d’un utilisateur existant de l’organisation et des identifiants des autorisations approuvées pour l’application. Utilisez une organisation de test pour évaluer cette procédure.
Lorsque vous détruisez une ressource openai_project, le projet est archivé au lieu d’être supprimé définitivement. Vous ne pouvez pas restaurer un projet archivé.
Délimitez le périmètre du projet
Créez un projet pour l’application :
resource "openai_project" "application" {
name = "example-application-development"
}Le projet délimite le périmètre dans lequel vous gérez l’utilisation de l’API par l’application, ses comptes de service, ses limites de débit, ses alertes de dépenses et les paramètres du projet. Terraform expose l’identifiant généré via openai_project.application.project_id. Les ressources du projet peuvent référencer cette valeur. Terraform crée donc le projet avant ces ressources.
Cet exemple utilise un nom précis. L’exemple complet présenté plus loin remplace ce nom par une variable pour que vous puissiez réutiliser la configuration dans plusieurs environnements.
Définissez les autorisations du projet
Créez un rôle de projet avec les autorisations approuvées pour l’application :
resource "openai_project_role" "application" {
project_id = openai_project.application.project_id
role_name = "Application API access"
description = "Permissions approved for this application"
permissions = ["api.webhooks.read"]
}La ressource openai_project_role définit les actions qu’une identité peut effectuer dans le projet. Dans cet exemple, le rôle autorise la lecture de la configuration des webhooks. Remplacez api.webhooks.read par les identifiants des autorisations approuvées pour votre application. Commencez par lui accorder uniquement les autorisations dont elle a besoin.
Toute modification de permissions met à jour le rôle. Exécutez terraform plan pour examiner chaque ajout ou retrait d’autorisation avant d’appliquer la modification.
Créez ou réutilisez un groupe
Créez un groupe dans l’organisation si Terraform doit en gérer le cycle de vie :
resource "openai_group" "application_access" {
name = "example-application-development-access"
}Les groupes sont définis au niveau de l’organisation. Vous pouvez donc les réutiliser dans plusieurs projets. Le suffixe -access indique que l’appartenance au groupe confère un droit d’accès et que le nom ne sert pas simplement à identifier une équipe.
Si un autre système gère un groupe existant, utilisez une source de données pour le consulter :
data "openai_group" "application_access" {
group_id = "group_123"
}La source de données lit les informations du groupe sans que cette configuration en gère le cycle de vie. Vous pouvez consulter les groupes gérés via SCIM, mais utilisez le système de gestion des identités qui en est responsable pour ajouter ou retirer des membres.
Accordez au groupe l’accès au projet
Attribuez au groupe le rôle personnalisé dans le projet :
resource "openai_project_group_role" "application_access" {
project_id = openai_project.application.project_id
group_id = openai_group.application_access.group_id
role_id = openai_project_role.application.role_id
}Cet exemple utilise le groupe géré par Terraform. Si vous avez réutilisé un groupe existant via la source de données, remplacez l’expression group_id par data.openai_group.application_access.group_id.
L’attribution du rôle relie trois objets :
project_ididentifie le projet auquel le groupe aura accès.group_ididentifie le groupe d’identités qui aura accès au projet.role_ididentifie le rôle qui détermine les autorisations accordées au groupe.
Les membres du groupe héritent du rôle personnalisé dans ce projet. La création d’un rôle ou d’un groupe ne suffit pas à accorder l’accès. C’est l’attribution du rôle au groupe qui accorde cet accès.
Ajoutez des utilisateurs et d’autres identités
Ajoutez une identité à un groupe de l’organisation géré par Terraform avec openai_group_user :
resource "openai_group_user" "application_developer" {
group_id = openai_group.application_access.group_id
user_id = "user_123"
}La valeur de user_id peut identifier un utilisateur ou un compte de service existant dans l’organisation. Pour ajouter un compte de service, utilisez openai_project_service_account.application.id comme valeur de user_id. Consultez le guide Comptes de service pour connaître les exigences relatives à l’accès des comptes de service via un groupe, à l’authentification et au cycle de vie des informations d’identification.
Attribuez le rôle directement à l’utilisateur si l’accès par groupe ne convient pas :
resource "openai_project_user_role" "application_developer" {
project_id = openai_project.application.project_id
user_id = "user_123"
role_id = openai_project_role.application.role_id
}Pour accorder des autorisations à l’échelle de l’organisation, créez un rôle d’organisation et attribuez-le directement à l’utilisateur ou via un groupe :
variable "organization_role_permissions" {
type = list(string)
}
resource "openai_role" "platform_operator" {
role_name = "Platform operator"
description = "Organization permissions for the platform team"
permissions = var.organization_role_permissions
}
resource "openai_user_role" "platform_operator" {
user_id = "user_123"
role_id = openai_role.platform_operator.role_id
}Renseignez organization_role_permissions avec les identifiants des autorisations approuvées au niveau de l’organisation. Séparez les autorisations de l’organisation de celles du projet afin de limiter la portée de chaque attribution au strict nécessaire.
Consultez les rôles actuellement attribués
Avant de modifier les accès, consultez les rôles d’organisation et de projet attribués à l’identité :
data "openai_user_roles" "current" {
user_id = "user_123"
}
data "openai_project_user_roles" "current" {
project_id = openai_project.application.project_id
user_id = "user_123"
}
output "organization_roles" {
value = data.openai_user_roles.current.roles
}
output "project_roles" {
value = data.openai_project_user_roles.current.roles
}Les sources de données indiquent les attributions en vigueur sans en confier la gestion à Terraform.
Supprimez des attributions de rôles
Si Terraform gère déjà une attribution de rôle, retirez le bloc de ressource correspondant de la configuration. Le prochain plan proposera de supprimer l’attribution sur la plateforme. Examinez le plan et vérifiez que les identités concernées conservent tous les accès nécessaires par un autre moyen.
Pour une attribution préexistante, déclarez d’abord la ressource correspondante et importez l’attribution à l’aide de l’identifiant composite indiqué dans la documentation. Vérifiez que le premier plan ne prévoit aucun changement avant de retirer la ressource de la configuration et d’appliquer la suppression.
Terraform peut uniquement supprimer les attributions enregistrées dans son état. Pour supprimer une attribution par défaut existante, importez-la d’abord dans la ressource Terraform correspondante. Retirez ensuite cette ressource de votre configuration et appliquez le plan de destruction qui en résulte. Si votre organisation n’autorise pas cette procédure d’importation puis de destruction, supprimez l’attribution en suivant une procédure approuvée via le tableau de bord ou l’API d’administration.
Consultez le guide Importation et réconciliation pour connaître les formats d’importation et les étapes à suivre pour confier en toute sécurité la gestion des ressources existantes à Terraform.
Exécutez l’exemple complet
Les exemples précédents utilisent des valeurs concrètes pour illustrer chaque relation. La configuration complète remplace les valeurs répétées propres à chaque environnement par des variables. Vous pouvez ainsi la réutiliser sans modifier les définitions des ressources.
Enregistrez la configuration suivante dans main.tf :
terraform {
required_version = ">= 1.0"
required_providers {
openai = {
source = "openai/openai"
version = ">= 1.0.0"
}
}
}
provider "openai" {}
variable "project_name" {
type = string
}
variable "project_role_permissions" {
type = list(string)
}
variable "user_id" {
type = string
}
resource "openai_project" "application" {
name = var.project_name
}
resource "openai_project_role" "application" {
project_id = openai_project.application.project_id
role_name = "Application API access"
description = "Permissions approved for this application"
permissions = var.project_role_permissions
}
resource "openai_group" "application_access" {
name = "${var.project_name}-access"
}
resource "openai_project_group_role" "application_access" {
project_id = openai_project.application.project_id
group_id = openai_group.application_access.group_id
role_id = openai_project_role.application.role_id
}
resource "openai_group_user" "application_developer" {
group_id = openai_group.application_access.group_id
user_id = var.user_id
}
output "project_id" {
value = openai_project.application.project_id
}
output "group_id" {
value = openai_group.application_access.group_id
}
output "project_role_id" {
value = openai_project_role.application.role_id
}Créez le fichier terraform.tfvars en indiquant un nom de projet unique, l’identifiant d’un utilisateur existant de l’organisation et les autorisations approuvées :
project_name = "example-application-development"
user_id = "user_123"
project_role_permissions = [
"api.webhooks.read",
]Initialisez Terraform, puis examinez et appliquez le plan enregistré :
terraform init
terraform fmt
terraform validate
terraform plan -out=tfplan
terraform show tfplan
terraform apply tfplanLe premier plan devrait prévoir l’ajout de cinq ressources. Une fois le plan appliqué, l’utilisateur hérite du rôle de projet personnalisé grâce à son appartenance au groupe, et terraform output affiche les identifiants du projet, du groupe et du rôle de projet. Exécutez de nouveau terraform plan pour vérifier que la configuration ne produit aucun autre changement.
Pour ajouter d’autres utilisateurs humains au groupe, reprenez le bloc qui ajoute un utilisateur au groupe et donnez à chaque ressource Terraform un nom unique. Pour configurer une identité non humaine, consultez le guide Comptes de service. Pour ajouter des garde-fous au projet, suivez les guides Contrôle des modèles, des outils et des données et Limites de débit et dépenses.