Hinzufügen von Anmeldenamen und Benutzern zu SQL Server—Hilfe

Hinzufügen eines Benutzers, der Daten erstellen kann
Erstellen von Anmeldungen und Benutzern mit SQL Server-Werkzeugen

In Microsoft SQL Server fügen Datenbankadministratoren Anmeldenamen zur SQL-Server Instanz hinzu. Diese Anmeldenamen werden Benutzern in verschiedenen Datenbanken auf der SQL Server-Instanz zugeordnet. Datenbankbenutzer, die Tabellen und Feature-Classes erstellen sollen, benötigen Berechtigungen zum Erstellen dieser Objekte in der Datenbank und müssen über ein Schema verfügen, in dem Sie diese erstellen können. Bei der Verwendung von ArcGIS muss dieses Schema den gleichen Namen wie der Datenbankbenutzer haben.

Mit dem Werkzeug oder Skript Datenbankbenutzer erstellen können Sie die folgenden Aktionen ausführen:

Einen Anmeldenamen zur SQL Server-Instanz erstellen oder hinzufügen
Einen Benutzer erstellen, der dem angegebenen Anmeldenamen zugeordnet ist
Ein passendes Schema für den Benutzer in der angegebenen Datenbank erstellen
Dem Benutzer ausreichende Berechtigungen zum Erstellen von Tabellen, Feature-Classes und Ansichten in der angegebenen Datenbank gewähren

Hinzufügen eines Benutzers, der Daten 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 einem Anmeldenamen mit sysadmin-Berechtigungen zur SQL Server-Instanz mit der Datenbank verbunden sein, um das Werkzeug Datenbankbenutzer erstellen auszuführen.

Wenn Sie einen Datenbankbenutzer für Windows-Anmeldedaten erstellen möchten, müssen die Windows-Anmeldedaten bereits vorhanden sein, bevor Sie das Werkzeug ausführen.

Verwenden des Werkzeugs Datenbankbenutzer erstellen

Starten Sie ArcMap oder ArcCatalog.
Stellen Sie mit einem Anmeldenamen mit sysadmin-Berechtigungen in der SQL Server-Instanz eine Verbindung mit der Datenbank oder Geodatabase her.
Öffnen Sie das Werkzeug Datenbankbenutzer erstellen.
Das Werkzeug befindet sich im Toolset "Geodatabase-Verwaltung" der Toolbox "Data Management".
Geben Sie die Datenbankverbindung für die Eingabe-Datenbankverbindung an.
Wählen Sie aus, ob Sie eine SQL Server-authentifizierte Anmeldung oder eine vorhandene Windows-authentifizierte Anmeldung verwenden möchten.
- Lassen Sie Betriebssystem-authentifizierten Benutzer erstellen deaktiviert, um eine Anmeldung mit SQL Server-Authentifizierung zu erstellen. Beachten Sie, dass bei SQL Server-Instanzen standardmäßig nur die Windows-Authentifizierung verwendet wird. Wenn die Verwendung der SQL Server- und Windows-Authentifizierung in der Instanz nicht konfiguriert ist, ist die Auswahl zur Erstellung einer Anmeldung mit Datenbankauthentifizierung nicht möglich.
- Aktivieren Sie Betriebssystem-authentifizierten Benutzer erstellen, um eine vorhandene Anmeldung mit Windows-Authentifizierung zu verwenden.
Geben Sie einen Namen für den Datenbankbenutzer ein, der von dem Werkzeug erstellt wird.
Wenn Sie eine Anmeldung mit SQL Server-Authentifizierung erstellen möchten, wird der hier eingegebene Name auch für die Anmeldung verwendet.
Geben Sie ein Kennwort für den Datenbankbenutzer ein.
Wenn Sie bereits über eine Datenbankrolle verfügen, der Sie diesen Benutzer hinzufügen möchten, geben Sie die Rolle an.
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:

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.

Speichern Sie die Datei mit der Erweiterung .py.
Führen Sie das Skript aus, und geben Sie dabei Optionen und Informationen zur SQL Server-Instanz und dem Benutzer, den Sie erstellen möchten, an.
Im folgenden Beispiel lautet der Name des Skripts "create_database_user.py". Es werden eine Anmeldung mit SQL Server-Authentifizierung (gisd_owner) in der SQL Server-Instanz "ssi5" und ein entsprechender Benutzer mit Schema in der Datenbank "gisdata" erstellt. Der Benutzer wird keiner Rolle hinzugefügt.
```
create_database_user.py --DBMS SQL_SERVER -i ssi5 -D gisdata --auth DATABASE_AUTH -U sa -P !nocopy! --utype DATABASE_USER -u gisd_owner -p T3mpPass
```
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.

Es gibt eine Reihe von Möglichkeiten für den Datenbesitzer, 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.

Sobald die Daten erstellt wurden, kann der Datenbesitzer anderen Benutzern Berechtigungen für die Datasets erteilen. Anweisungen finden Sie unter Gewähren und Widerrufen von Dataset-Berechtigungen.

Erstellen von Anmeldungen und Benutzern mit SQL Server-Werkzeugen

Wenn Sie einen Benutzer 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 SQL Server-Werkzeuge verwenden. Beachten Sie bei der Erstellung eigener Anmeldungen und Benutzer, die mit ArcGIS verwendet werden sollen, Folgendes:

Alle Datenbankbenutzer, die Daten erstellen, müssen über ein Schema in der Datenbank verfügen. Dieses Schema muss den gleichen Namen wie der Benutzer haben.
Sie können Windows-Gruppen anstatt einzelnen Windows-Benutzern den Zugriff auf SQL Server gewähren, um die Erstellung und Verwaltung von Anmeldungen zu vereinfachen. Alle Mitglieder der Windows-Gruppe können sich bei SQL Server anmelden. Server-, Datenbank- und Dataset-Berechtigungen, die der Gruppe gewährt werden, gelten automatisch für jedes Mitglied der Gruppe. Beachten Sie jedoch, dass Sie nicht nur ein Schema zum Speichern der von allen Gruppenmitgliedern erzeugten Daten erstellen können. Jeder Benutzer in der Gruppe, der Daten in der Geodatabase erstellt, muss ein eigenes Schema haben, in dem die Daten gespeichert werden. SQL Server erstellt einen Benutzer und ein Schema in der Datenbank, wenn ein Gruppenmitglied das erste Mal Daten erstellt. Dies erfolgt automatisch. Schemas und Benutzer müssen nicht manuell erstellt werden.

Anweisungen zum Erstellen von Anmeldungen, Benutzern und Schemas mit den SQL Server-Werkzeugen finden Sie in der Microsoft SQL Server-Dokumentation.