Ajouter des rôles de connexion dans PostgreSQL—ArcMap

Disponible avec une licence Standard ou Advanced.

Ajouter un utilisateur qui peut créer des objets de base de données
Créer des identifiants de connexion pour afficher et modifier des données

PostgreSQL utilise des rôles pour se connecter à la grappe 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 la grappe de bases de données PostgreSQL, ainsi qu’une structure d’appariement pour l’utilisateur dans la base de données que vous spécifiez et 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 ou PL/pgSQL pour créer un rôle dans la grappe 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.

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 Desktop ou appeler l’outil dans un script Python pour créer un utilisateur de base de données qui est en mesure de 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

Démarrez un client ArcGIS Desktop.
Connectez-vous à la base de données ou à la géodatabase à l’aide d’un rôle doté de l’autorité de superutilisateur PostgreSQL.
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.
Identifiez la connexion à la base de données pour la Connexion à la base de données en entrée.
Attribuez un nom au rôle de connexion et à la structure que l'outil va créer.
Saisissez un mot de passe pour l'utilisateur de la base de données.
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.
Cliquez sur OK (ArcMap) ou Run (Exécuter) (ArcGIS Pro).

Exécuter un script Python

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

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
"""

# 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 Desktop Standard or Advanced, ArcGIS Engine with the Geodatabase Update extension, or ArcGIS 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 le programme ArcGIS Desktop (Standard ou Advanced), ArcGIS Server (Standard ou Advanced) ou encore ArcGIS Engine avec l’extension Geodatabase Update est installé.

Enregistrez le fichier avec l'extension .py.
Exécutez le script en indiquant des options et des informations propres à votre grappe 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 Microsoft 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 la grappe 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. Si vous procédez ainsi pour votre géodatabase dans PostgreSQL, vérifiez toutefois que le groupe public ou l’utilisateur spécifique dispose des privilèges requis pour créer des tables temporaires.

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.

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.

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.
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 (Editors) et un groupe pour ceux qui peuvent seulement afficher les données (Viewers).
```
CREATE ROLE editors 
NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT;
CREATE ROLE viewers
NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT;
```
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.
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.
Accordez le privilège usage sur la structure des géodonnées à chaque groupe de connexion.
Le privilège usage autorise les membres éditeurs et 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;
```
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 le privilège usage aux groupes des éditeurs et 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 des é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.