ArcMap

Hinzufügen von Anmelderollen zu 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 dessen Eigentum 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 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.

Wenn Sie eine Anmelderolle erstellen möchten, die kein Schema besitzt und deshalb keine Objekte in der Geodatabase erstellen kann, können Sie mit einer PostgreSQL-Client-Anwendung wie pgAdmin III oder PL/pgSQL eine Rolle im PostgreSQL-Datenbank-Cluster erstellen.

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.

Hinzufügen eines Benutzers, der Datenbankobjekte erstellen kann

Sie können das Werkzeug Datenbankbenutzer erstellen in ArcGIS for Desktop verwenden oder das Werkzeug in einem Python-Skript aufrufen, um einen Datenbankbenutzer zu erstellen, der Tabellen, Feature-Classes und Ansichten 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 ArcMap oder ArcCatalog.
  2. Stellen Sie sich mit einer Rolle mit Superuser-Status eine Verbindung mit der Datenbank oder Geodatabase her.
  3. Öffnen Sie das Werkzeug Datenbankbenutzer erstellen.

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

  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 OK, um das Werkzeug auszufü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
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)

    Sie können das Skript auf einem Computer ausführen, auf dem ArcGIS for Desktop (Standard oder Advanced), ArcGIS for Server (Standard oder Advanced) oder ArcGIS Engine mit der Erweiterung Geodatabase Update 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 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

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

Es gibt eine Reihe von Möglichkeiten für diesen Benutzer, um Tabellen in der Datenbank oder Geodatabase zu erstellen. Weitere Informationen zum Erstellen von Tabellen mit ArcGIS finden Sie unter Überblick über das Hinzufügen von Datasets zur Geodatabase.

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 jedoch für Ihre Enterprise-Geodatabase ausführen, müssen Sie den Typ der Protokolltabellen Ihrer Geodatabase ändern.

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

Ändern von Protokolldateieinstellungen

Geodatabases in PostgreSQL verwenden freigegebene Protokolldateitabellen, um eine Liste ausgewählter Datensätze zu führen. Diese Protokolldatei-Tabellentypen setzen voraus, dass alle Benutzer über ein Schema verfügen, in dem diese Tabellen erstellt werden. Wenn Sie Anmelderollen erstellen möchten, die keine Tabellen in der Geodatabase erstellen können, müssen Sie die Einstellungen für Protokolldateitabellen so ändern, dass Protokolldatei-Tabellenpools verwendet werden, deren Besitzer der Benutzer "sde" ist. Eine Beschreibung von Protokolldateipools finden Sie unter Konfigurationsoptionen für Protokolldateitabellen in PostgreSQL-Geodatabases.

Befolgen Sie die Anweisungen unter Ändern der Einstellungen von Protokolldateitabellen, um die Einstellungen von Protokolldateitabellen zu ändern.

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 zunächst mit dem Befehl CREATE ROLE zwei Anmeldegruppen: eine für Benutzer, die Datasets bearbeiten können (editors), und eine für Benutzer, die nur Daten 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 namens "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 namens "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 erlaubt 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.

Nachdem die Datenbank oder Geodatabase Datasets enthält, kann der Besitzer 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 gewähren. Anweisungen finden Sie unter Gewähren und Widerrufen von Dataset-Berechtigungen.