Einrichten einer Enterprise-Geodatabase in SQL Server—Hilfe

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

Sie sind der SQL Server- und Geodatabase-Administrator
Der SQL Server-Administrator erstellt die Datenbank, der Geodatabase-Administrator erstellt die Geodatabase

Die Art der Einrichtung einer Geodatabase in Microsoft SQL Server hängt von der Situation vor Ort ab. Befolgen Sie die Anweisungen für die Szenarien, die auf Ihre Organisation zutreffen.

Sie sind der SQL Server- und Geodatabase-Administrator.
Der SQL Server-Administrator erstellt die Datenbank, der Geodatabase-Administrator erstellt die Geodatabase.

Sie sind der SQL Server- und Geodatabase-Administrator

Wenn Sie sowohl Datenbank-Administrator als auch Geodatabase-Administrator sind und deshalb das Kennwort für beide Anmeldenamen kennen, können Sie mit dem Geoverarbeitungswerkzeug oder Python-Skript Enterprise-Geodatabase erstellen eine Datenbank in SQL Server erstellen.

Mit dem Werkzeug Enterprise-Geodatabase erstellen ist die Einrichtung einer Geodatabase völlig unkompliziert, da damit die Datenbankobjekte erstellt und die erforderlichen Berechtigungen für Sie gewährt werden. Um dies zu erreichen, werden bestimmte Standardeinstellungen verwendet. Im Folgenden wird beschrieben, welche Aufgaben vom Werkzeug Enterprise-Geodatabase erstellen ausgeführt und welche Einstellungen dabei verwendet werden:

Die Datenbanktabellen (MDF und LDF) werden im SQL Server-Standardverzeichnis auf dem Server erstellt.
Die Größe der Datenbankdateien entspricht entweder der von Ihnen definierten Größe für die SQL Server-Modelldatenbank oder 500 MB für die MDF-Datei und 125 MB für die LDF-Datei, je nachdem, welcher Wert größer ist.
Wenn Sie eine Geodatabase in einem Schema mit dem Namen "sde" erstellen, erzeugt das Werkzeug eine Anmeldung "sde" mit SQL Server-Authentifizierung in der SQL Server-Instanz und erstellt einen Benutzer "sde" in der Datenbank, den es der Anmeldung "sde" zuordnet. Außerdem wird ein Schema "sde" in der Datenbank erzeugt, dem SDE-Benutzerberechtigungen zum Erstellen einer Geodatabase und Beenden von Verbindungen mit der SQL Server-Instanz gewährt werden.
Es wird eine Geodatabase erstellt.

Bevor Sie das Werkzeug oder Skript zum Erstellen einer Geodatabase ausführen, müssen Sie eine SQL Server-Instanz einrichten.

Einrichten von SQL Server

Bevor Sie eine Geodatabase erstellen, muss SQL Server installiert und die Instanz konfiguriert werden. Die spezifische Konfiguration der Instanz hängt von den individuellen Anforderungen Ihrer Organisation ab. Beachten Sie jedoch, dass für die SQL Server-Instanz eine Sortierung verwendet werden muss, bei der nicht zwischen Groß- und Kleinschreibung unterschieden wird.

Überprüfen Sie die ArcGIS-Systemanforderungen, bevor Sie eine Geodatabase einrichten, um sicherzustellen, dass die gewünschten Datenbankmanagementsystem-, ArcGIS- und Hardwarekombinationen unterstützt werden. Stellen Sie nach der Installation von SQL Server sicher, die Akzeptanz von Remote-Verbindungen in SQL Server zu konfigurieren. Standardmäßig sind Remote-Verbindungen nicht aktiviert.

Informationen zur Installation und Konfiguration finden Sie in der Microsoft-Dokumentation für SQL Server.

Installieren Sie nach der Installation und Konfiguration von SQL Server die ArcGIS- und SQL Server-Clients.

Konfigurieren eines ArcGIS-Clients

Sie können ein Python-Skript über ArcGIS for Desktop (Standard oder Advanced), ArcGIS Engine Runtime Geodatabase Update oder über ArcGIS for Server (Standard oder Advanced) ausführen, um eine Geodatabase zu erstellen. Wenn Sie das Geoverarbeitungswerkzeug Enterprise-Geodatabase erstellen anstelle eines Skripts ausführen möchten, verwenden Sie ArcGIS for Desktop.

In den meisten Fällen wird der ArcGIS-Client auf einem anderen Computer als SQL Server installiert. Deshalb muss auf dem ArcGIS-Client-Computer eine unterstützte Version von SQL Server Native Client installiert sein, damit eine Verbindung mit der SQL Server-Datenbank hergestellt werden kann. Sehen Sie in der Dokumentation von Microsoft nach, um zu erfahren, welche Version des SQL Server Native Client Sie installieren sollten, um eine Verbindung zu der von Ihnen verwendeten Version der SQL-Servers herzustellen.

Sie können den SQL Server Native Client von My Esri oder aus dem Microsoft Download Center herunterladen. Befolgen Sie die Anweisungen von Microsoft für die Installation des SQL Server Native Client auf Ihrem Client-Computer.

Installieren Sie den ArcGIS-Client, den Sie für die Erstellung der Geodatabase verwenden möchten.

Befolgen Sie die Anleitungen, die in den Installationsanweisungen der Software bereitgestellt werden.
Installieren Sie einen SQL Server-Client auf dem ArcGIS-Client-Computer.

Wenn Sie den SQL Server Native Client auf einem 64-Bit-Betriebssystem installieren, verwenden Sie die ausführbare Datei für 64-Bit SQL Server Native Client. Diese ausführbare Datei installiert sowohl den 32- als auch den 64-Bit-Client und ermöglicht somit die Verwendung mit 32- und 64-Bit-Anwendungen. Wenn Sie den SQL Server Native Client mit 32-Bit auf einem 64-Bit-Betriebssystem installieren, schlägt die Ausführung fehl.

Jetzt können Sie eine Geodatabase erstellen.

Erstellen einer Geodatabase

Sie können entweder das Werkzeug Enterprise-Geodatabase erstellen von ArcGIS for Desktop (Standard oder Advanced) oder ein Python-Skript von einem ArcGIS for Desktop (Standard oder Advanced)-, ArcGIS for Server- oder ArcGIS Engine-Client ausführen, um eine Datenbank und Geodatabase zu erstellen.

Ausführen des Werkzeugs Enterprise-Geodatabase erstellen

Wenn Sie Zugriff auf ArcGIS for Desktop haben, können Sie ein Geoverarbeitungswerkzeug ausführen, um die Geodatabase zu erstellen.

Starten Sie ArcMap oder ArcCatalog.
Öffnen Sie das Werkzeug Enterprise-Geodatabase erstellen.

Sie können dieses Werkzeug suchen oder zu diesem Werkzeug navigieren, das sich im Toolset "Geodatabase-Verwaltung" der Toolbox "Data Management" befindet.
Wählen Sie aus der Dropdown-Liste Datenbankplattform den Eintrag SQL Server aus.
Geben Sie im Textfeld Instanz den Namen der SQL Server-Instanz ein, mit der Sie eine Verbindung herstellen möchten.
Geben Sie im Textfeld Datenbank den Namen der Datenbank ein, in der die Geodatabase gespeichert werden soll.

Wenn noch keine Datenbank mit diesem Namen in der SQL Server-Instanz vorhanden ist, wird sie erstellt. Falls sie bereits vorhanden ist, wird die Geodatabase in der angegebenen Datenbank gespeichert.
Stellen Sie eine Verbindung mit SQL Server als Systemadministrator her. Dies erfolgt entweder mithilfe der Betriebssystemauthentifizierung, die Mitglied der festgelegten Serverrolle "sysadmin" in SQL Server ist, oder durch die Eingabe eines Datenbankbenutzernamens und -kennworts für einen sysadmin-Benutzer.
- Um sich mit einer sysadmin-Betriebssystemauthentifizierung anmelden zu können, müssen Sie Betriebssystemauthentifizierung aktivieren. Sie müssen mit dem richtigen Anmeldenamen bei Windows angemeldet sein, um diese Option zu verwenden.
- Um sich als sysadmin anzumelden, geben Sie den Benutzernamen "sysadmin" in das Textfeld Datenbankadministrator und das entsprechende Kennwort in das Textfeld Datenbankadministratorkennwort ein.
Wählen Sie das Schema aus, das die Geodatabase enthält:
- Wenn Sie den Benutzer mit dem Namen "sde" als Geodatabase-Administrator auswählen und die Geodatabase im Schema des SDE-Benutzers speichern möchten, aktivieren Sie die Option SDE-Schema.
- Wenn Sie den DBO-Benutzer als Geodatabase-Administrator auswählen und die Geodatabase in einem DBO-Schema speichern möchten, deaktivieren Sie die Option SDE-Schema.
Weitere Informationen zum Speichern der Geodatabase im Schema "sde" oder "dbo" finden Sie unter Ein Vergleich von Windows- und Datenbankauthentifizierung in SQL Server.

Wenn Sie ein SDE-Schema auswählen, enthält das Textfeld Geodatabase-Administrator bereits den Namen "sde". Wenn noch kein Benutzer mit diesem Namen in der Datenbank vorhanden ist, werden der Benutzer und das entsprechende Schema erstellt und dem Benutzer werden die zum Erstellen einer Geodatabase erforderlichen Berechtigungen zugewiesen.

Wenn Sie die Datenbankauthentifizierung und ein DBO-Schema zum Speichern der Geodatabase verwenden, geben Sie den Namen des DBO-Benutzers der SQL Server-Instanz in das Textfeld Geodatabase-Administrator ein.

Wenn Sie mithilfe der Betriebssystemauthentifizierung eine Verbindung mit der Datenbank herstellen, muss der aktuelle Anmeldename Bestandteil der festgelegten Serverrolle "sysadmin" in der SQL Server-Instanz sein, um eine DBO-Schema-Geodatabase erstellen zu können.

Geben Sie ein Kennwort für den Geodatabase-Administrator in das Textfeld Geodatabase-Administratorkennwort ein.

Wenn der von Ihnen angegebene Geodatabase-Administrator bereits in der Datenbank vorhanden ist, müssen Sie das richtige Kennwort für den vorhandenen Benutzer eingeben. Das Kennwort kann nicht mit diesem Werkzeug geändert werden.
Um eine Autorisierungsdatei anzugeben, wechseln Sie zu der Schlüsselcodedatei, die bei der Autorisierung von ArcGIS for Server erstellt wurde, und wählen Sie diese aus.

Diese Datei wird auf Windows-Servern im Ordner \\Program Files\ESRI\License<release#>\sysgen gespeichert. Autorisieren Sie ArcGIS for Server jetzt, um diese Datei zu erstellen, sofern Sie dies nicht bereits getan haben.
Klicken Sie auf OK, um das Werkzeug auszuführen.

Im SQL Server-Standardverzeichnis werden eine Datenbank und Protokolldateien erstellt, sofern Sie keine vorhandene Datenbank angegeben haben. Es wird eine Geodatabase in der Datenbank erstellt. Wenn Sie eine SDE-Schema-Geodatabase ausgewählt haben, werden eine SQL Server-authentifizierte SDE-Anmeldung, ein Datenbankbenutzer und ein Schema erstellt.

Zum Erstellen der Geodatabase wird eine Protokolldatei (GDBCreateGeodatabase<#>.log) in das Verzeichnis geschrieben, das für die Variable "%TEMP%" auf dem Computer angegeben wurde, auf dem das Werkzeug ausgeführt wird. Falls Sie Probleme beim Ausführen des Werkzeugs haben, überprüfen Sie diese Protokolldatei, um das Problem zu beheben.

Als Nächstes können Sie einen Benutzer erstellen, der Daten in die Geodatabase laden kann.

Ausführen eines Python-Skripts

Sie können das hier verfügbare Skript kopieren, speichern und ausführen, um eine Geodatabase von ArcGIS for Desktop (Standard oder Advanced), ArcGIS for Server (Standard oder Advanced) oder ArcGIS Runtime (Geodatabase Update) zu erstellen.

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

"""
Name: create_enterprise_gdb.py
Description: Provide connection information to a DBMS instance and create an enterprise geodatabase.
Type  create_enterprise_gdb.py -h or create_enterprise_gdb.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 " + arcpy.GetInstallInfo()['Version'] )

#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:  Do not specify 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 ("--schema", dest="Schema_type", type="choice", choices=['SDE_SCHEMA', 'DBO_SCHEMA'], default="SDE_SCHEMA", help="Schema type  applies to geodatabases in SQL Server only. Type SDE_SCHEMA to create geodatabase in SDE schema or type DBO_SCHEMA to create geodatabase in DBO schema. Default=SDE_SCHEMA")
parser.add_option ("-u", dest="Gdb_admin", type="string", default="", help="Geodatabase administrator user name; Must always be sde for PostgreSQL, sde-schema geodatabases in SQL Server, and master sde geodatabase in Oracle")
parser.add_option ("-p", dest="Gdb_admin_pwd", type="string", default="", help="Geodatabase administrator password")
parser.add_option ("-t", dest="Tablespace", type="string", default="", help="Tablespace name; For PostgreSQL, type name of existing tablespace in which to store database. If no tablespace name specified, pg_default is used. For Oracle, type name of existing tablespace, or, if tablespace with specified name does not exist, it will be created and set as the default tablespace for the sde user. If no tablespace name is specified, SDE_TBS tablespace is created and set as sde user default. Tablespace name not supported for SQL Server.")
parser.add_option ("-l", dest="Authorization_file", type="string", default="", help="Full path and name of authorization file; file created when ArcGIS for Server Enterprise authorized, and stored in \\Program Files\ESRI\License<release#>\sysgen on Windows or /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release#>/sysgen on Linux")
# 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
	schema_type = options.Schema_type.upper()
	gdb_admin = options.Gdb_admin
	gdb_admin_pwd = options.Gdb_admin_pwd	
	tablespace = options.Tablespace
	license = options.Authorization_file
	
	
	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 (license == ""):
		print(" \n%s: error: \n%s\n" % (sys.argv[0], "Authorization file (-l) must be specified."))
		parser.print_help()
		sys.exit(3)			
	
	if(database_type == "SQL_SERVER"):
		if(schema_type == "SDE_SCHEMA" and gdb_admin.lower() != "sde"):
			print("\n%s: error: %s\n" % (sys.argv[0], "To create SDE schema on SQL Server, geodatabase administrator must be SDE."))
			sys.exit(3)
		if (schema_type == "DBO_SCHEMA" and gdb_admin != ""):
			print("\nWarning: %s\n" % ("Ignoring geodatabase administrator specified when creating DBO schema..."))
		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 (schema_type == "DBO_SCHEMA"):
			print("\nWarning: %s %s, %s\n" % ("Only SDE schema is supported on", database_type, "switching to SDE schema..." ))
			
		if( gdb_admin.lower() == ""):
			print("\n%s: error: %s\n" % (sys.argv[0], "Geodatabase administrator must be specified."))
			sys.exit(3)

		if( gdb_admin.lower() != "sde"):
			if (database_type == "ORACLE"):
				print("\nGeodatabase admin user is not SDE, creating user schema geodatabase on Oracle...\n")
			else:
				print("\n%s: error: %s for %s.\n" % (sys.argv[0], "Geodatabase administrator must be SDE", database_type))
				sys.exit(3)
			
		if( dbms_admin == ""):
			print("\n%s: error: %s\n" % (sys.argv[0], "DBMS administrator must be specified!"))
			sys.exit(3)

		if (account_authentication == "OPERATING_SYSTEM_AUTH"):
			print("Warning: %s %s, %s\n" % ("Only database authentication is supported on", database_type, "switching to database authentication..." ))

	# 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 an enterprise geodatabase 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 enterprise geodatabase.")
	else:
		print("\n" + product_license + " license available!  Continuing to create...")
		arcpy.AddMessage("+++++++++")
	
	
	try:
		print("Creating enterprise geodatabase...\n")
		arcpy.CreateEnterpriseGeodatabase_management(database_platform=database_type,instance_name=instance, database_name=database, account_authentication=account_authentication, database_admin=dbms_admin, database_admin_password=dbms_admin_pwd, sde_schema=schema_type, gdb_admin_name=gdb_admin, gdb_admin_password=gdb_admin_pwd, tablespace_name=tablespace, authorization_file=license)
		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)

Speichern Sie die Datei mit der Erweiterung .py.
Führen Sie das Skript aus, indem Sie für Ihre Site spezifische Optionen und Informationen bereitstellen.
Im folgenden Beispiel wird die Datei "create_gdb.py" ausgeführt, um die Datenbank "entgdb" in der SQL Server-Instanz "porthos\gisprod" zu erstellen. Das Werkzeug wird über die Datenbankauthentifizierung als Benutzer "sa" ausgeführt, und es wird eine Geodatabase im Benutzerschema "sde" erstellt. Im Standardverzeichnis des ArcGIS-Servers wird eine Schlüsselcodedatei angegeben, um die Geodatabase zu autorisieren.
```
create_gdb.py --DBMS SQL_SERVER -i porthos\gisprod -D entgdb --auth DATABASE_AUTH 
-U sa -P N0pe3king! --schema SDE_SCHEMA -u sde -p Tgdbst@rtsh3r3 -l \\Program Files\ESRI\License10.3\sysgen\keycodes
```
In diesem Beispiel wird dasselbe Skript ausgeführt, wobei eine Anmeldung beim Client-Computer mit einem Anmeldenamen, der Mitglied der festgelegten sysadmin-Serverrolle ist, für die Erstellung einer Geodatabase im DBO-Schema besteht:
```
create_gdb.py --DBMS SQL_SERVER -i porthos\gisprod -D entgdb --auth OPERATING_SYSTEM_AUTH 
--schema DBO_SCHEMA -l \\Program Files\ESRI\License10.3\sysgen\keycodes
```
Tipp:
Geben Sie in der Eingabeaufforderung -h oder --help ein, um die Syntaxhilfe aufzurufen.

Sie verfügen nun über eine Geodatabase in SQL Server.

Zum Erstellen der Geodatabase wird eine Protokolldatei (GDBCreateGeodatabase<#>.log) in das Verzeichnis geschrieben, das für die %TEMP%-Variable auf dem Computer angegeben wurde, auf dem das Skript ausgeführt wird.

Als Nächstes können Sie einen Benutzer erstellen, der Daten in die Geodatabase laden kann.

Der SQL Server-Administrator erstellt die Datenbank, der Geodatabase-Administrator erstellt die Geodatabase

Wenn die Person, die die Geodatabase erstellt, keinen Zugriff auf das Kennwort des Datenbankadministrators hat, kann der Datenbank-Administrator die Datenbank einrichten und den Anmeldenamen, den Benutzer und das Schema des Geodatabase-Administrators erstellen. Wenn die Geodatabase im SDE-Schema gespeichert werden soll, erstellt der Datenbank-Administrator einen SDE-Anmeldenamen und -benutzer und ein SDE-Schema. Wenn die Geodatabase im DBO-Schema gespeichert werden soll, erstellt der Datenbank-Administrator eine Anmeldung und einen Benutzer und weist den Benutzer dem Besitzer der Datenbank zu. Weitere Informationen zu den Speicheroptionen für Geodatabases finden Sie unter Ein Vergleich von Windows- und Datenbankauthentifizierung in SQL Server.

Der Geodatabase-Administrator kann als Geodatabase-Administrator eine Verbindung mit der Datenbank herstellen und mit dem Geoverarbeitungswerkzeug Enterprise Geodatabase aktivieren oder einem Python-Skript eine Geodatabase erstellen.

Das Werkzeug Enterprise-Geodatabase aktivieren verwendet eine Datenbankverbindungsdatei als Eingabe und erstellt die Geodatabase-Systemtabellen, -sichten, -funktionen und -prozeduren.

Einrichten von SQL Server

Bevor der Geodatabase-Administrator eine Geodatabase erstellen kann, muss der SQL Server-Administrator folgende Aktionen ausführen:

Installieren und konfigurieren Sie SQL Server. Die spezifische Konfiguration der Instanz hängt von den individuellen Anforderungen Ihrer Organisation ab. Überprüfen Sie die ArcGIS-Systemanforderungen, bevor Sie eine Geodatabase einrichten, um sicherzustellen, dass die gewünschten Datenbankmanagementsystem-, ArcGIS- und Hardwarekombinationen unterstützt werden. Stellen Sie nach der Installation von SQL Server sicher, die Akzeptanz von Remote-Verbindungen in SQL Server zu konfigurieren. Standardmäßig sind Remote-Verbindungen nicht aktiviert. Informationen zur Installation und Konfiguration finden Sie in der Microsoft-Dokumentation für SQL Server.
Erstellen Sie eine Datenbank.
Fügen Sie einen Anmeldenamen hinzu, der einem Datenbankbenutzer mit dem Namen "sde" oder einem Datenbankbenutzer, der Datenbankbesitzer ist, zugeordnet wird, oder erstellen Sie einen solchen Anmeldenamen.
Erstellen Sie bei Verwendung einer SDE-Schema-Geodatabase ein Schema mit dem Namen "sde" in der Datenbank. Legen Sie dieses als Standardschema des Benutzers "sde" fest.
Wenn Sie eine SDE-Schema-Geodatabase verwenden, muss der Benutzer "sde" mindestens die folgenden Berechtigungen haben: CREATE FUNCTION, CREATE PROCEDURE, CREATE TABLE und CREATE VIEW. Weitere Informationen zu Berechtigungen finden Sie unter Berechtigungen für Geodatabases in SQL Server.

Konfigurieren eines ArcGIS-Clients

Der Geodatabase-Administrator kann ein Python-Skript über ArcGIS for Desktop (Standard oder Advanced), ArcGIS Engine Runtime Geodatabase Update oder ArcGIS for Server (Standard oder Advanced) ausführen, um eine Geodatabase zu erstellen. Wenn Sie das Geoverarbeitungswerkzeug Enterprise-Geodatabase aktivieren anstelle eines Skripts ausführen möchten, verwenden Sie ArcGIS for Desktop.

Installieren Sie den ArcGIS-Client, den Sie für die Erstellung der Geodatabase verwenden möchten.

Befolgen Sie die Anleitungen, die in den Installationsanweisungen der Software bereitgestellt werden.
Installieren Sie einen SQL Server-Client auf dem ArcGIS-Client-Computer.

Wenn Sie den SQL Server Native Client auf einem 64-Bit-Betriebssystem installieren, verwenden Sie die ausführbare Datei für 64-Bit SQL Server Native Client. Diese ausführbare Datei installiert sowohl den 32- als auch den 64-Bit-Client und ermöglicht somit die Verwendung mit 32- und 64-Bit-Anwendungen. Wenn Sie den SQL Server Native Client mit 32-Bit auf einem 64-Bit-Betriebssystem installieren, schlägt die Ausführung fehl.

Der ArcGIS-Client ist bereit und kann eine Verbindung zur Datenbank herstellen und eine Geodatabase erstellen. Erstellen Sie mit einer der im nächsten Abschnitt beschriebenen Methoden eine Geodatabase.

Erstellen einer Geodatabase

Der Geodatabase-Administrator kann das Werkzeug Enterprise-Geodatabase aktivieren von ArcGIS for Desktop (Standard oder Advanced) oder ein Python-Skript von einem ArcGIS for Desktop-, ArcGIS for Server- oder ArcGIS Engine-Client ausführen, um eine Geodatabase in der vorhandenen Datenbank zu erstellen.

Führen Sie das Werkzeug Enterprise-Geodatabase aktivieren aus.

Sie können das Werkzeug Enterprise-Geodatabase aktivieren von ArcGIS for Desktop ausführen, um eine Geodatabase in einer vorhandenen SQL Server-Datenbank zu erstellen.

Starten Sie ArcMap oder ArcCatalog.
Stellen Sie vom Kataloginhaltsverzeichnis als Geodatabase-Administrator eine Verbindung mit der SQL Server-Datenbank her.

Vergessen Sie nicht, das Kennwort des Benutzers im Dialogfeld Datenbankverbindung zu speichern.
Klicken Sie mit der rechten Maustaste auf die Datenbankverbindung und wählen Sie Geodatabase aktivieren.

Das Werkzeug Enterprise-Geodatabase aktivieren wird geöffnet, und im Textfeld Eingabe-Datenbankverbindung wird der Name und Speicherort der Verbindungsdatei eingefügt.
Navigieren Sie zu der ArcGIS for Server-Autorisierungsdatei, die bei der Autorisierung von ArcGIS for Server erstellt wurde, und fügen Sie sie dem Textfeld Autorisierungsdatei hinzu.

Wenn Sie zum Autorisieren von ArcGIS for Server den Assistenten verwenden, wird eine Schlüsselcodedatei auf dem Server erzeugt, auf dem die Software installiert ist. Wenn Sie ArcGIS for Server auf einem Linux-System autorisiert haben, wurde die Schlüsselcode-Datei im Verzeichnis /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release>/sysgen erstellt. Wenn Sie die Autorisierung auf einem Windows-Server ausgeführt haben, wurde die Datei im Verzeichnis Program Files\ESRI\License<release>\sysgen erstellt. Autorisieren Sie ArcGIS for Server, um diese Datei zu erstellen, sofern Sie dies nicht bereits getan haben.
Klicken Sie auf OK, um das Werkzeug auszuführen.

Es wird eine Geodatabase in der Datenbank erstellt.

Als Nächstes können Sie einen Benutzer erstellen, der Daten in die Geodatabase laden kann.

Ausführen eines Python-Skripts

Wenn Sie die Geodatabase durch das Ausführen eines Skripts von einer ArcGIS for Server-, ArcGIS for Desktop- oder ArcGIS Engine-Installation auf einem Windows-Computer erstellen möchten, können Sie das hier verfügbare Skript dazu verwenden.

Führen Sie die folgenden Schritte aus, um ein Python-Skript zum Erstellen einer Geodatabase in einer vorhandenen SQL Server-Datenbank zu erstellen:

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

"""
Name: enable_enterprise_gdb.py
Description: Provide connection information to an enterprise database
and enable enterprise geodatabase.
Type enable_enterprise_gdb.py -h or enable_enterprise_gdb.py --help for usage
Author: Esri
"""

# Import system modules
import arcpy, os, optparse, sys


# Define usage and version
parser = optparse.OptionParser(usage = "usage: %prog [Options]", version="%prog 1.0 for " + arcpy.GetInstallInfo()['Version'] )

#Define help and options
parser.add_option ("--DBMS", dest="Database_type", type="choice", choices=['SQLSERVER', 'ORACLE', 'POSTGRESQL', 'DB2','INFORMIX','DB2ZOS', ''], default="", help="Type of enterprise DBMS:  SQLSERVER, ORACLE, POSTGRESQL, DB2, INFORMIX, or DB2ZOS.")
parser.add_option ("-i", dest="Instance", type="string", default="", help="DBMS instance name")
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="User", type="string", default="", help="Geodatabase administrator user name")
parser.add_option ("-p", dest="Password", type="string", default="", help="Geodatabase  administrator password")
parser.add_option ("-D", dest="Database", type="string", default="none", help="Database name:  Not required for Oracle")
parser.add_option ("-l", dest="Authorization_file", type="string", default="", help="Full path and name of authorization file")


# 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
	account_authentication = options.account_authentication.upper()
	username = options.User.lower() 
	password = options.Password	
	database = options.Database.lower()
	license = options.Authorization_file


	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 (license == ""):
		print " \n%s: error: \n%s\n" % (sys.argv[0], "Authorization file (-l) must be specified.")
		parser.print_help()
		sys.exit(3)

	if (database_type == "SQLSERVER"):
		database_type = "SQL_SERVER"
		
	# Get the current product license
	product_license=arcpy.ProductInfo()
	
	if (license == ""):
		print " \n%s: error: %s\n" % (sys.argv[0], "Authorization file (-l) must be specified.")
		parser.print_help()
		sys.exit(3)
	
	# Checks required license level
	if product_license.upper() == "ARCVIEW" or product_license.upper() == 'ENGINE':
		print "\n" + product_license + " license found!" + "  Enabling enterprise geodatabase functionality 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 enabling an enterprise geodatabase.")
	else:
		print "\n" + product_license + " license available!  Continuing to enable..."
		arcpy.AddMessage("+++++++++")
	
	# Local variables
	instance_temp = instance.replace("\\","_")
	instance_temp = instance_temp.replace("/","_")
	instance_temp = instance_temp.replace(":","_")
	Conn_File_NameT = instance_temp + "_" + database + "_" + username    
	
	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)
	
	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(out_folder_path=temp, out_name=Connection_File_Name, database_platform=database_type, instance=instance, database=database, account_authentication=account_authentication, username=username, password=password, 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")
	
	
	# Process: Enable geodatabase...
	try:
		print "Enabling Enterprise Geodatabase...\n"
		arcpy.EnableEnterpriseGeodatabase_management(input_database=Connection_File_Name_full_path, authorization_file=license)
		for i in range(arcpy.GetMessageCount()):
			arcpy.AddReturnMessage(i)
		arcpy.AddMessage("+++++++++\n")
	except:
		for i in range(arcpy.GetMessageCount()):
			arcpy.AddReturnMessage(i)
			
	if os.path.exists(Connection_File_Name_full_path):
		os.remove(Connection_File_Name_full_path)
			
#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)

Speichern Sie die Datei mit der Erweiterung .py.
Führen Sie das Skript aus, indem Sie für Ihre Site spezifische Optionen und Informationen bereitstellen.
Im folgenden Beispiel wird die Datei "enable_gdb.py" für die Datenbank "spdata" auf der Instanz "ssprod" ausgeführt. Die Verbindung wird als SDE-Anmeldung mit dem Kennwort "Tgdbst@rtsh3r3" hergestellt. Im Standardverzeichnis des ArcGIS-Servers wird eine Schlüsselcodedatei angegeben, um die Geodatabase zu autorisieren.
```
enable_gdb.py --DBMS SQL_SERVER -i ssprod --auth DATABASE_AUTH 
-u sde -p Tgdbst@rtsh3r3 -D spdata -l \\Program Files\ESRI\License10.3\sysgen\keycodes
```
Tipp:
Geben Sie in der Eingabeaufforderung -h oder --help ein, um die Syntaxhilfe aufzurufen.

Sie verfügen nun über eine Geodatabase in der SQL Server-Datenbank.

Als Nächstes können Sie einen Benutzer erstellen, der Daten in die Geodatabase laden kann.