Hinzufügen von Anmelderollen für PostgreSQL

Mit der Standard- oder Advanced-Lizenz verfügbar.

PostgreSQL verwendet Rollen für die Anmeldung am Datenbank-Cluster und an den Datenbanken. Einzelne Benutzer werden als Anmelderollen bezeichnet. Zudem müssen Sie für alle Anmelderollen, die Eigentümer von Objekten in der Geodatabase sind, ein Schema in dieser Datenbank erstellen. Um PostgreSQL mit ArcGIS zu verwenden, muss das Schema den gleichen Namen wie die Anmelderolle haben und sich in deren Besitz befinden.

Mit dem Werkzeug Datenbankbenutzer erstellen können Sie eine Anmelderolle hinzufügen, die Tabellen und Feature-Classes erstellen kann. Das Werkzeug erstellt eine Anmelderolle mit Datenbankauthentifizierung im PostgreSQL-Datenbank-Cluster und ein passendes Schema für den Benutzer in der angegebenen Datenbank und gewährt der Öffentlichkeit usage-Berechtigungen für das neue Schema.

Um eine Anmelderolle zu erstellen, die kein Schema besitzt und deshalb keine Objekte in der Geodatabase erstellen kann, oder um eine Anmelderolle zu erstellen, die einer SSPI-Anmeldung (Security Support Provider Interface) oder einer LDAP-Anmeldung (Lightweight Directory Access Protocol) zugeordnet ist, verwenden Sie eine PostgreSQL-Client-Anwendung, wie zum Beispiel pgAdmin, oder PL/pgSQL zum Erstellen einer Rolle im PostgreSQL-Datenbank-Cluster.

Sie können alternativ auch Gruppenrollen erstellen, denen die Anmelderollen hinzugefügt werden. Auf diese Weise können Sie Berechtigungen für die Gruppe festlegen, die für alle zugehörigen Anmelderollen gelten. Mit dem Werkzeug oder Skript Rolle erstellen können Sie Gruppenrollen erstellen. Alternativ können Sie dazu SQL verwenden.

Hinweis:

Sie müssen jedoch weiterhin ein passendes Schema für jede Anmelderolle in der Gruppe erstellen, die Eigentümer von Objekten in der Geodatabase ist. Sie können kein Schema für die Gruppenrolle erstellen.

Hinzufügen eines Benutzers, der Datenbankobjekte erstellen kann

Sie können das Werkzeug Datenbankbenutzer erstellen in ArcGIS AllSource verwenden oder das Werkzeug in einem Python-Skript aufrufen, um einen Datenbankbenutzer zu erstellen, der Tabellen, Feature-Classes und Sichten erstellen kann.

Sie müssen mit einer Rolle mit Superuser-Status mit der Datenbank verbunden sein, um das Werkzeug Datenbankbenutzer erstellen ausführen zu können.

Verwenden des Werkzeugs Datenbankbenutzer erstellen

  1. Starten Sie ArcGIS AllSource.
  2. Stellen Sie mit einer Rolle mit PostgreSQL-Administratorberechtigung eine Verbindung mit der Datenbank oder Geodatabase her.
  3. Öffnen Sie das Werkzeug Datenbankbenutzer erstellen.

    Das Werkzeug befindet sich in der Toolbox "Data Management" im Toolset "Geodatabase-Verwaltung".

  4. Geben Sie die Datenbankverbindung für die Eingabe-Datenbankverbindung an.
  5. Geben Sie einen Namen für die Anmelderolle und das Schema an, die von dem Werkzeug erstellt werden.
  6. Geben Sie ein Kennwort für den Datenbankbenutzer ein.
  7. Wenn Sie bereits über eine Gruppenrolle verfügen, der dieser Benutzer als Mitglied angehören soll, geben Sie die Rolle an.
  8. Klicken Sie auf Ausführen.

Ausführen eines Python-Skripts

Führen Sie die folgenden Schritte aus, um ein Skript für die Benutzererstellung zu erzeugen:

  1. Erstellen Sie eine Textdatei auf einem ArcGIS-Client-Computer, und kopieren Sie das folgende Skript in die Datei.

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

    Sie können das Skript auf einem Computer ausführen, auf dem ArcGIS AllSource (ArcGIS Desktop Standard oder Advanced) oder ArcGIS Server installiert ist.

  2. Speichern Sie die Datei mit der Erweiterung .py.
  3. Führen Sie das Skript aus, und geben Sie dabei Optionen und Informationen zum PostgreSQL-Datenbank-Cluster und der Anmelderolle, die Sie erstellen möchten, an.

    Im folgenden Beispiel wird das Skript mit dem Namen create_database_user.py auf einem Microsoft Windows-Server ausgeführt. Im PostgreSQL-Datenbank-Cluster "pgdb7" wird eine Anmelderolle mit Datenbankauthentifizierung (geodata) erstellt, ein entsprechendes Schema wird in der Datenbank "gisdata" erstellt. Der Benutzer wird keiner Gruppenrolle hinzugefügt.

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

    Dies ist ein Beispiel für die Ausführung des Skripts auf einem Linux-Computer:

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

    Tipp:

    Geben Sie in der Eingabeaufforderung -h oder --help ein, um die Syntaxhilfe aufzurufen.

Die Datenbank enthält nun einen Benutzer, der Tabellen erstellen kann.

Erstellen von Anmeldenamen zum Anzeigen und Bearbeiten von Daten

Sie können mit SQL Anmelderollen für Benutzer erstellen, die keine Daten erstellen. Wenn Sie dies für Ihre Geodatabase in PostgreSQL durchführen, müssen Sie sicherstellen, dass die öffentliche Gruppe oder der spezifische Benutzer über Berechtigungen zum Erstellen temporärer Tabellen verfügt.

Sie können auch Anmeldegruppen erstellen, damit Berechtigungen für einzelne Datasets leichter für diese Benutzer gewährt werden können.

Erstellen von Rollen

In den folgenden Schritten wird beschrieben, wie mit psql Gruppenrollen erstellt werden, um die Verwaltung von Datenberechtigungen zu vereinfachen und Anmelderollen zu erstellen, die den Gruppenrollen angehören.

  1. Melden Sie sich bei psql als Benutzer mit der Berechtigung zum Erstellen anderer Rollen im Datenbank-Cluster an.

    Dabei kann es sich um eine Anmeldung mit Superuser-Status oder der createrole-Berechtigung handeln.

  2. Erstellen Sie mit dem Befehl create role zwei Anmeldegruppen: eine für Benutzer, die Datasets bearbeiten können ("editors"), und eine für Benutzer, die Daten nur anzeigen können ("viewers").

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

  3. Erstellen Sie als Nächstes Anmelderollen, die Mitglieder der Gruppe "editors" sind.

    In diesem Beispiel wird eine Anmelderolle (editor1) mit einem verschlüsselten Kennwort erstellt. Die Rolle verfügt nicht über den Superuser-Status und kann weder Datenbanken noch Rollen im Datenbank-Cluster erstellen. Sie wurde jedoch zum Mitglied der Gruppenrolle "editors" gemacht und übernimmt die Berechtigungen dieser Gruppenrolle.

    CREATE ROLE editor1 LOGIN 
    ENCRYPTED PASSWORD 'sooper.secret' 
    NOSUPERUSER NOCREATEDB NOCREATEROLE INHERIT IN ROLE editors;
    Ändern Sie den Anmelderollennamen, und führen Sie die Anweisung erneut aus, um weitere Anmelderollen zu erstellen, die Daten in der Geodatabase bearbeiten können.

  4. Erstellen Sie nun Anmelderollen, die Mitglieder der Gruppe "viewers" sind.

    In diesem Beispiel wird eine Anmelderolle (reader1) mit einem verschlüsselten Kennwort erstellt. Die Rolle verfügt nicht über den Superuser-Status und kann weder Datenbanken noch Rollen im Datenbank-Cluster erstellen. Sie wurde jedoch zum Mitglied der Gruppenrolle "viewers" gemacht und übernimmt die Berechtigungen dieser Gruppenrolle.

    CREATE ROLE reader1 LOGIN 
    ENCRYPTED PASSWORD 'almostas.secret' 
    NOSUPERUSER NOCREATEDB NOCREATEROLE INHERIT IN ROLE viewers;
    Ändern Sie den Anmelderollennamen, und führen Sie die Anweisung erneut aus, um weitere Anmelderollen zu erstellen, die nur Daten in der Geodatabase anzeigen können.

  5. Gewähren Sie den beiden Anmeldegruppen die Berechtigung usage für das Schema "geodata".

    Die Berechtigung usage ermöglicht den Mitgliedern der Gruppen "editors" und "viewers", auf Daten im Schema "geodata" zuzugreifen. Ohne dies kann "geodata" den Mitgliedern der Gruppenrollen "viewers" und "editors" keine Berechtigungen für einzelne Datasets gewähren.

    GRANT USAGE ON SCHEMA geodata TO editors;
    GRANT USAGE ON SCHEMA geodata TO viewers;
  6. Wenn Sie diese Anmeldungen für eine Geodatabase erstellen und die Berechtigungen für das Schema "sde" geändert haben, sodass die Öffentlichkeit keine usage-Berechtigungen dafür hat, gewähren Sie den Gruppen "editors" und "viewers" die Berechtigung usage für das Schema "sde".
    GRANT USAGE ON SCHEMA sde TO editors;
    GRANT USAGE ON SCHEMA sde TO viewers;

Die Datenbank verfügt nun über einen oder mehrere Benutzer, die Daten bearbeiten, und einen oder mehrere Benutzer, die Daten anzeigen.

Sobald die Datenbank oder Geodatabase Datasets enthält, kann der Besitzer ArcGIS-Werkzeuge verwenden, um der Gruppe "viewers" die Berechtigung select für die Datasets und der Gruppe "editors" die Berechtigungen select, insert, update und delete für die Datasets zu gewähren. Anweisungen finden Sie unter Gewähren und Widerrufen von Dataset-Berechtigungen.