Nach oben

Hinzufügen von Anmelderollen für PostgreSQL

In diesem Thema

  1. Hinzufügen eines Benutzers, der Datenbankobjekte erstellen kann
  2. Erstellen von Anmeldenamen zum Anzeigen und Bearbeiten von Daten

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 Pro 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 Pro.
  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 Pro (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.

Feedback zu diesem Thema?

In diesem Thema
  1. Hinzufügen eines Benutzers, der Datenbankobjekte erstellen kann
  2. Erstellen von Anmeldenamen zum Anzeigen und Bearbeiten von Daten