Nach oben

Hinzufügen von Benutzern zu Oracle

In diesem Thema

  1. Hinzufügen eines Benutzers, der Datenbankobjekte erstellen kann
  2. Erstellen von Benutzern mit Oracle-Werkzeugen

Oracle-Datenbankadministratoren erstellen Benutzerkonten in der Oracle-Instanz und weisen diesen Speicher (Tablespaces) und Berechtigungen zu.

Der Datenbankadministrator (sys-Benutzer) kann mithilfe von Oracle-Werkzeugen Benutzer und einen Standard-Tablespace für den Benutzer erstellen und Berechtigungen zum Erstellen von Datenbankobjekten erteilen. Alternativ kann der Datenbankadministrator mit dem Werkzeug oder Skript Datenbankbenutzer erstellen von einem ArcGIS-Client einen Datenbankbenutzer erstellen. Mit diesem Werkzeug erstellten Datenbankbenutzern werden die folgenden Berechtigungen erteilt:

  • CREATE SESSION
  • CREATE SEQUENCE
  • CREATE TABLE
  • CREATE TRIGGER
  • CREATE VIEW
  • SELECT ON DBA_ROLES

Hinzufügen eines Benutzers, der Datenbankobjekte erstellen kann

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

Sie müssen als Oracle-sys-Benutzer mit der Datenbank verbunden sein, um das Werkzeug Datenbankbenutzer erstellen ausführen zu können.

Verwenden des Werkzeugs Datenbankbenutzer erstellen

  1. Starten Sie einen ArcGIS Desktop-Client.
  2. Stellen Sie als sys-Benutzer 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 den Benutzer 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. Geben Sie den Namen des Tablespace ein, der als Standard-Tablespace des Benutzers festgelegt werden soll. Falls der Tablespace noch nicht vorhanden ist, wird er am Standardspeicherort von Oracle erstellt. Das Werkzeug erstellt einen 400 MB großen Tablespace.

    Wenn Sie keinen Tablespace angeben, wird der Standard-Tablespace von Oracle verwendet.

  9. Klicken Sie auf OK (ArcMap) oder Ausführen (ArcGIS Pro).

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 Desktop (Standard oder Advanced), ArcGIS 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 zur Oracle-Datenbank und dem Benutzer, den Sie erstellen möchten, an.

    Im folgenden Beispiel wird das Skript mit dem Namen "create_database_user.py" auf einem Windows-Server ausgeführt. Mithilfe der Oracle-Verbindungszeichenfolge "dbsrv/orcl" wird ein Benutzer mit Datenbankauthentifizierung (geodata) in der Datenbank erstellt. Der Benutzer wird keiner Rolle hinzugefügt.

    create_database_user.py --DBMS ORACLE -i dbsrv/orcl -U sys -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 ORACLE -i dbsrv/orcl -U sys -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.

Nachdem die Datasets erstellt wurden, kann der Besitzer den Benutzern, die die Daten anzeigen müssen, SELECT-Berechtigungen für die Datasets erteilen, und den Benutzern, die die Daten bearbeiten müssen, SELECT-, INSERT-, UPDATE- und DELETE-Berechtigungen. Anweisungen finden Sie unter Gewähren und Widerrufen von Dataset-Berechtigungen.

Erstellen von Benutzern mit Oracle-Werkzeugen

Wenn Sie einen Datenbankbenutzer erstellen möchten, dessen Berechtigungen sich von den mit dem Werkzeug Datenbankbenutzer erstellen gewährten Berechtigungen unterscheiden oder dem keine Berechtigungen direkt gewährt werden, können Sie dazu die Oracle-Werkzeuge verwenden.

Anweisungen zum Erstellen von Datenbankbenutzern mit den Oracle-Werkzeugen finden Sie in der Oracle-Dokumentation.

Feedback zu diesem Thema?

In diesem Thema
  1. Hinzufügen eines Benutzers, der Datenbankobjekte erstellen kann
  2. Erstellen von Benutzern mit Oracle-Werkzeugen