Ajouter des rôles de connexion dans PostgreSQL

Disponible avec une licence Standard ou Advanced.

PostgreSQL utilise des rôles pour se connecter au cluster de bases de données et aux bases de données. Les utilisateurs individuels sont appelés des rôles de connexion. Pour tous les rôles de connexion qui posséderont des objets dans la géodatabase, vous devez également créer une structure dans cette base de données. Pour utiliser PostgreSQL avec ArcGIS, la structure doit porter le même nom que le rôle de connexion et appartenir à ce dernier.

Vous pouvez utiliser l'outil Créer un utilisateur de base de données pour ajouter un rôle de connexion qui peut créer des tables et des classes d'entités. L'outil crée un rôle de connexion dans l'agrégat de bases de données PostgreSQL, ainsi qu'une structure appariée pour l'utilisateur dans la base de données spécifiée et il accorde au public des privilèges USAGE sur la nouvelle structure.

Pour créer un rôle de connexion qui ne possède pas de structure et ne peut donc pas créer d'objets dans la géodatabase, vous pouvez utiliser une application cliente PostgreSQL telle que pgAdmin III ou PL/pgSQL pour créer un rôle dans l'agrégat de bases de données PostgreSQL.

Vous pouvez également créer des rôles de groupe auxquels des rôles de connexion peuvent être ajoutés. Vous pouvez ensuite attribuer des autorisations au groupe, qui s'appliqueront à tous les rôles de connexion associés. Vous pouvez utiliser l'outil Créer un rôle ou un script pour créer des rôles de groupe, ou utiliser SQL.

Remarque :

Vous devez créer une structure correspondante pour chaque rôle de connexion dans le groupe qui possédera des objets dans la géodatabase. Vous ne pouvez pas créer une structure pour le rôle de groupe.

Ajouter un utilisateur qui peut créer des objets de base de données

Vous pouvez exécuter l'outil Créer un utilisateur de base de données à partir d'ArcGIS for Desktop ou appeler l'outil dans un script Python pour créer un utilisateur de base de données pouvant créer des tables, des classes d'entités et des vues.

Vous devez être connecté à la base de données avec un rôle de superutilisateur pour exécuter l'outil Créer un utilisateur de base de données.

Utiliser l'outil Créer un utilisateur de base de données

1. Démarrez ArcMap ou ArcCatalog.
2. Connectez-vous à la base de données ou à la géodatabase avec un rôle de superutilisateur.
3. Ouvrez l'outil Créer un utilisateur de base de données.

   Il se trouve dans le jeu d'outils Administration de géodatabase de la boîte à outils Gestion des données.

4. Identifiez la connexion à la base de données pour la Connexion à la base de données en entrée.
5. Attribuez un nom au rôle de connexion et à la structure que l'outil va créer.
6. Saisissez un mot de passe pour l'utilisateur de la base de données.
7. Si vous disposez déjà d'un rôle de groupe auquel vous souhaitez ajouter cet utilisateur en tant que membre, indiquez le rôle.
8. Cliquez sur OK pour exécuter l'outil.

Exécuter un script Python

Pour générer un script de création d'utilisateur, procédez comme suit :

1. Créez un fichier texte sur l'ordinateur d'un client ArcGIS, puis copiez-y le script suivant.

   """
   Name: create_database_user.py
   Description: Provide connection information to a database user.
   Type create_database_user.py -h or create_database_user.py --help for usage
   Author: Esri
   """
   
   # Import system modules
   import arcpy
   import os
   import optparse
   import sys
   
   
   # Define usage and version
   parser = optparse.OptionParser(usage = "usage: %prog [Options]", version="%prog 1.0 for 10.1 release")
   
   #Define help and options
   parser.add_option ("--DBMS", dest="Database_type", type="choice", choices=['SQLSERVER', 'ORACLE', 'POSTGRESQL', ''], default="", help="Type of enterprise DBMS:  SQLSERVER, ORACLE, or POSTGRESQL.")                   
   parser.add_option ("-i", dest="Instance", type="string", default="", help="DBMS instance name")
   parser.add_option ("-D", dest="Database", type="string", default="none", help="Database name:  Not required for Oracle")
   parser.add_option ("--auth", dest="Account_authentication", type ="choice", choices=['DATABASE_AUTH', 'OPERATING_SYSTEM_AUTH'], default='DATABASE_AUTH', help="Authentication type options (case-sensitive):  DATABASE_AUTH, OPERATING_SYSTEM_AUTH.  Default=DATABASE_AUTH")
   parser.add_option ("-U", dest="Dbms_admin", type="string", default="", help="DBMS administrator user")
   parser.add_option ("-P", dest="Dbms_admin_pwd", type="string", default="", help="DBMS administrator password")
   parser.add_option ("--utype", dest="user_type", type ="choice", choices=['DATABASE_USER', 'OPERATING_SYSTEM_USER'], default='DATABASE_USER', help="Authentication type options (case-sensitive):  DATABASE_USER, OPERATING_SYSTEM_USER.  Default=DATABASE_USER")
   parser.add_option ("-u", dest="dbuser", type="string", default="", help="database user name")
   parser.add_option ("-p", dest="dbuser_pwd", type="string", default="", help="database user password")
   parser.add_option ("-r", dest="role", type="string", default="", help="role to be granted to the user")
   parser.add_option ("-t", dest="Tablespace", type="string", default="", help="Tablespace name")
   # Check if value entered for option
   try:
   	(options, args) = parser.parse_args()
   
   	#Check if no system arguments (options) entered
   	if len(sys.argv) == 1:
   		print "%s: error: %s\n" % (sys.argv[0], "No command options given")
   		parser.print_help()
   		sys.exit(3)
   
   	#Usage parameters for spatial database connection
   	database_type = options.Database_type.upper()
   	instance = options.Instance
   	database = options.Database.lower()	
   	account_authentication = options.Account_authentication.upper()
   	dbms_admin = options.Dbms_admin
   	dbms_admin_pwd = options.Dbms_admin_pwd
   	dbuser = options.dbuser
   	dbuser_pwd = options.dbuser_pwd	
   	tablespace = options.Tablespace
   	user_type = options.user_type
   	role = options.role
   
   	
   	if (database_type == "SQLSERVER"):
   		database_type = "SQL_SERVER"
   	
   	if( database_type ==""):	
   		print(" \n%s: error: \n%s\n" % (sys.argv[0], "DBMS type (--DBMS) must be specified."))
   		parser.print_help()
   		sys.exit(3)		
   	
   	if(database_type == "SQL_SERVER"):
   		if( account_authentication == "DATABASE_AUTH" and dbms_admin == ""):
   			print("\n%s: error: %s\n" % (sys.argv[0], "DBMS administrator must be specified with database authentication"))
   			sys.exit(3)
   		if( account_authentication == "OPERATING_SYSTEM_AUTH" and dbms_admin != ""):
   			print("\nWarning: %s\n" % ("Ignoring DBMS administrator specified when using operating system authentication..."))
   	else:		
   		if( dbuser.lower() == ""):
   			print("\n%s: error: %s\n" % (sys.argv[0], "Database user must be specified."))
   			sys.exit(3)		
   		if( dbms_admin == ""):
   			print("\n%s: error: %s\n" % (sys.argv[0], "DBMS administrator must be specified!"))
   			sys.exit(3)
   
   	if ( user_type == "DATABASE_USER" and (dbuser =="" or dbuser_pwd =="")):
   		print(" \n%s: error: \n%s\n" % (sys.argv[0], "To create database authenticated user, user name and password must be specified!"))
   		parser.print_help()
   		sys.exit(3)	
   
   	# Get the current product license
   	product_license=arcpy.ProductInfo()
   	
   	# Checks required license level
   	if product_license.upper() == "ARCVIEW" or product_license.upper() == 'ENGINE':
   		print("\n" + product_license + " license found!" + "  Creating a user in an enterprise geodatabase or database requires an ArcGIS for Desktop Standard or Advanced, ArcGIS Engine with the Geodatabase Update extension, or ArcGIS for Server license.")
   		sys.exit("Re-authorize ArcGIS before creating a database user.")
   	else:
   		print("\n" + product_license + " license available!  Continuing to create...")
   		arcpy.AddMessage("+++++++++")
   
   	# Local variables
   	instance_temp = instance.replace("\\","_")
   	instance_temp = instance_temp.replace("/","_")
   	instance_temp = instance_temp.replace(":","_")
   	Conn_File_NameT = instance_temp + "_" + database + "_" + dbms_admin   
   
   	if os.environ.get("TEMP") == None:
   		temp = "c:\\temp"	
   	else:
   		temp = os.environ.get("TEMP")
   	
   	if os.environ.get("TMP") == None:
   		temp = "/usr/tmp"		
   	else:
   		temp = os.environ.get("TMP")  
   
   	Connection_File_Name = Conn_File_NameT + ".sde"
   	Connection_File_Name_full_path = temp + os.sep + Conn_File_NameT + ".sde"
   	
   	# Check for the .sde file and delete it if present
   	arcpy.env.overwriteOutput=True
   	if os.path.exists(Connection_File_Name_full_path):
   		os.remove(Connection_File_Name_full_path)
   
   	try:
   		print("\nCreating Database Connection File...\n")
   		# Process: Create Database Connection File...
   		# Usage:  out_file_location, out_file_name, DBMS_TYPE, instnace, database, account_authentication, username, password, save_username_password(must be true)
   		#arcpy.CreateDatabaseConnection_management(temp , Connection_File_Name, database_type, instance, database, account_authentication, dbms_admin, dbms_admin_pwd, "TRUE")
   		arcpy.CreateDatabaseConnection_management(out_folder_path=temp, out_name=Connection_File_Name, database_platform=database_type, instance=instance, database=database, account_authentication=account_authentication, username=dbms_admin, password=dbms_admin_pwd, save_user_pass="TRUE")
   	        for i in range(arcpy.GetMessageCount()):
   			if "000565" in arcpy.GetMessage(i):   #Check if database connection was successful
   				arcpy.AddReturnMessage(i)
   				arcpy.AddMessage("\n+++++++++")
   				arcpy.AddMessage("Exiting!!")
   				arcpy.AddMessage("+++++++++\n")
   				sys.exit(3)            
   			else:
   				arcpy.AddReturnMessage(i)
   				arcpy.AddMessage("+++++++++\n")
   
   		print("Creating database user...\n")
   		arcpy.CreateDatabaseUser_management(input_workspace=Connection_File_Name_full_path, user_authentication_type=user_type, user_name=dbuser, user_password=dbuser_pwd, role=role, tablespace_name=tablespace)
   		for i in range(arcpy.GetMessageCount()):
   			arcpy.AddReturnMessage(i)
   		arcpy.AddMessage("+++++++++\n")
   	except:
   		for i in range(arcpy.GetMessageCount()):
   			arcpy.AddReturnMessage(i)
   			
   #Check if no value entered for option	
   except SystemExit as e:
   	if e.code == 2:
   		parser.usage = ""
   		print("\n")
   		parser.print_help()   
   		parser.exit(2)
   

   Vous pouvez exécuter le script à partir d'un ordinateur sur lequel ArcGIS for Desktop (Standard ou Advanced), ArcGIS for Server (Standard ou Advanced) ou ArcGIS Engine et l'extension Geodatabase Update sont installés.

2. Enregistrez le fichier avec l'extension .py.
3. Exécutez le script en indiquant des options et des informations propres à votre agrégat de bases de données PostgreSQL et au rôle de connexion que vous voulez créer.

   Dans l'exemple suivant, exécuté sur un serveur Windows, le nom du script est create_database_user.py. Un rôle de connexion authentifié par la base de données (géodonnées) est créé dans l'agrégat de bases de données PostgreSQL pgdb7 et une structure correspondante est créée dans la base de données gisdata. L'utilisateur n'est pas ajouté à un rôle de groupe.

   create_database_user.py --DBMS POSTGRESQL -i pgdb7 -D gisdata -U postgres -P $hHhH --utype DATABASE_USER -u geodata -p 0wn1t
   

   Voici un exemple d'exécution du script sur un ordinateur Linux :

   ./create_database_user.py --DBMS POSTGRESQL -i pgdb7 -D gisdata -U postgres -P $hHhH --utype DATABASE_USER -u geodata -p 0wn1t
   

   Astuce:

   Saisissez -h ou --help à l'invite de commande pour obtenir de l'aide sur la syntaxe.

Votre base de données contient désormais un utilisateur qui peut créer des tables.

Plusieurs méthodes permettent à cet utilisateur de créer des tables dans la base de données ou la géodatabase. Pour plus d'informations sur la création de tables à l'aide d'ArcGIS, reportez-vous à la rubrique Vue d'ensemble de l'ajout de jeux de données à une géodatabase.

Créer des identifiants de connexion pour afficher et modifier des données

Vous pouvez utiliser SQL pour créer des rôles de connexion pour les utilisateurs qui ne vont pas créer de données. Toutefois, si vous procédez ainsi pour votre géodatabase d'entreprise, vous devez modifier le type de tables de fichiers journaux utilisé par votre géodatabase.

Vous pouvez également créer des groupes de connexion pour faciliter l'octroi de privilèges sur des jeux de données individuels à ces utilisateurs.

Modifier les paramètres des fichiers journaux

Dans PostgreSQL, les géodatabases utilisent des tables de fichiers journaux partagés pour assurer la maintenance des listes d'enregistrements sélectionnés. Ces types de tables de fichiers journaux exigent de tous les utilisateurs qu'ils possèdent une structure dans laquelle créer ces tables. Pour créer des rôles de connexion qui ne peuvent pas créer des tables dans la géodatabase, vous devez modifier les paramètres des tables de fichiers journaux pour qu'elles utilisent des groupes de tables de fichiers journaux appartenant à l'utilisateur sde. Pour plus d'informations sur les groupes de fichiers journaux, reportez-vous à la rubrique Options des tables de fichiers journaux pour les géodatabases dans PostgreSQL.

Pour modifier les paramètres des tables de fichiers journaux, suivez les instructions de la rubrique Modifier les paramètres des tables de fichiers journaux.

Créer des rôles

Les étapes suivantes expliquent comment utiliser psql pour créer des rôles de groupe simplifiant la gestion des privilèges sur les données et pour créer des rôles de connexion appartenant à des rôles de groupes.

1. Connectez-vous à psql en tant qu'utilisateur autorisé à créer d'autres rôles dans l'agrégat de bases de données. Vous pouvez utiliser un identifiant de connexion de superutilisateur ou un identifiant de connexion qui détient le privilège CREATEROLE.
2. Tout d'abord, utilisez la commande CREATE ROLE pour créer deux groupes de connexion : un groupe pour les utilisateurs qui peuvent modifier des jeux de données (éditeurs) et un groupe pour ceux qui peuvent uniquement afficher les données (visualiseurs).

   CREATE ROLE editors 
   NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT;
   
   CREATE ROLE viewers
   NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT;
   

3. Créez ensuite des rôles de connexion membres du groupe d'éditeurs.

   Dans cet exemple, un rôle de connexion editor1 est créé avec un mot de passe chiffré. Le rôle n'a pas le statut de superutilisateur et ne peut pas créer de base de données ni de rôles dans l'agrégat de bases de données. Toutefois, il a été ajouté au rôle de groupe éditeurs et héritera des privilèges de ce rôle de groupe.

   CREATE ROLE editor1 LOGIN 
   ENCRYPTED PASSWORD 'sooper.secret' 
   NOSUPERUSER NOCREATEDB NOCREATEROLE INHERIT IN ROLE editors;
   

   Modifiez le nom du rôle de connexion et réexécutez l'instruction pour créer des rôles de connexion supplémentaires qui pourront modifier les données de la géodatabase.

4. Créez ensuite des rôles de connexion membres du groupe de visualiseurs.

   Dans cet exemple, un rôle de connexion reader1 est créé avec un mot de passe chiffré. Le rôle n'a pas le statut de superutilisateur et ne peut pas créer de base de données ni de rôles dans l'agrégat de bases de données. Toutefois, il a été ajouté au rôle de groupe visualiseurs et héritera des privilèges de ce rôle de groupe.

   CREATE ROLE reader1 LOGIN 
   ENCRYPTED PASSWORD 'almostas.secret' 
   NOSUPERUSER NOCREATEDB NOCREATEROLE INHERIT IN ROLE viewers;
   

   Modifiez le nom du rôle de connexion et réexécutez l'instruction pour créer des rôles de connexion supplémentaires qui pourront uniquement visualiser les données de la géodatabase.

5. Accordez le privilège USAGE sur la structure des géodonnées à chaque groupe de connexion.

   Le privilège USAGE autorise les membres des groupes d'éditeurs et de visualiseurs à accéder aux données de la structure des géodonnées. Sinon, les géodonnées ne pourraient pas accorder de privilèges sur des jeux de données individuels aux membres des rôles de groupe visualiseurs et éditeurs.

   GRANT USAGE ON SCHEMA geodata TO editors;
   GRANT USAGE ON SCHEMA geodata TO viewers;
   

6. Si vous créez ces identifiants de connexion pour une géodatabase et que vous avez modifié les privilèges de la structure sde pour que le public ne bénéficie pas du privilège USAGE, accordez ce privilège aux groupes d'éditeurs et de visualiseurs sur la structure sde.

   GRANT USAGE ON SCHEMA sde TO editors;
   GRANT USAGE ON SCHEMA sde TO viewers;
   

Votre base de données comporte désormais un ou plusieurs utilisateurs autorisés à modifier les données et un ou plusieurs utilisateurs autorisés à les visualiser.

Lorsque la base de données ou la géodatabase contient des jeux de données, le propriétaire peut accorder des privilèges SELECT sur ces derniers au groupe de visualiseurs et des privilèges SELECT, INSERT, UPDATE et DELETE au groupe d'éditeurs sur les jeux de données. Reportez-vous à la rubrique Octroyer et supprimer des privilèges sur le jeu de données pour obtenir des instructions.