Erstellen einer Geodatabase in SQL Server

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

Um eine Geodatabase in einer Microsoft SQL Server-Datenbank zu erstellen, führen Sie auf einem ArcGIS-Client ein Geoverarbeitungswerkzeug oder ein Python-Skript aus.

Wenn Sie eine Enterprise-Geodatabase mit ArcGIS Pro 3.3 erstellen, lautet die Geodatabase-Version 11.3.0.

Lesen Sie zuerst die Voraussetzungen, folgen Sie dann den für Ihre Situation relevanten Anweisungen.

Voraussetzungen

Um eine SQL Server-Geodatabase zu erstellen, gehen Sie wie folgt vor:

  1. Prüfen Sie, ob die gewünschte Kombination aus ArcGIS, SQL Server und Betriebssystem kompatibel ist.
  2. Laden Sie den SQL Server-ODBC-Client herunter, der zum Herstellen einer Verbindung mit der SQL Server-Version erforderlich ist, die Sie zum Speichern der Geodatabase verwenden möchten.
  3. Rufen Sie eine ArcGIS Server-Keycode-Datei ab, und legen Sie sie an einem Speicherort ab, auf den Sie über den ArcGIS-Client zugreifen können, den Sie zum Erstellen der Geodatabase verwenden möchten.
  4. Bestimmen Sie, wer die Geodatabase erstellen soll. Dies hat Einfluss darauf, wer die Datenbank erstellt. Legen Sie zudem fest, mit welchem Werkzeug Sie die Geodatabase erstellen möchten. Befolgen Sie die Anweisungen, die für Ihre Situation gelten:

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 Geodatabase in einer SQL Server-Datenbank 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. Dazu werden die folgenden Standardeinstellungen verwendet und die folgenden Datenbankobjekte erstellt:

  • Die Datenbanktabellen (MDF und LDF) werden im SQL Server-Standardverzeichnis auf dem Server erstellt.
  • Dabei werden die SQL Server-Datenbankoptionen "READ_COMMITTED_SNAPSHOT" und "ALLOW_SNAPSHOT_ISOLATION" auf "ON" eingestellt.
  • Die Größe entspricht der standardmäßigen Größe für Datenbankdateien, die Sie für die SQL Server-Modelldatenbank definiert haben, bzw. 500 MB für die MDF-Datei und 125 MB für die LDF-Datei, je nachdem, welcher Wert größer ist.
  • Wenn Sie in einem Schema namens "sde" eine Geodatabase erstellen, erzeugt das Werkzeug in der SQL Server-Instanz die Anmeldung "sde" mit Datenbankauthentifizierung und in der Datenbank den Benutzer "sde", der der Anmeldung "sde" zugeordnet wird. Außerdem erstellt das Werkzeug das Schema "sde" in der Datenbank und gewährt SDE-Benutzerberechtigungen zum Erstellen von Geodatabases und zum Beenden von Verbindungen mit der SQL Server-Instanz.
  • Die Geodatabase-Objekte werden innerhalb der SQL Server-Instanz erstellt.

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

Installieren und Konfigurieren 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 Anforderungen Ihrer Organisation ab.

Hinweis:

Für die SQL Server-Instanz muss eine Sortierung verwendet werden, bei der nicht zwischen Groß- und Kleinschreibung unterschieden wird. Für die Datenbank darf keine türkische Sortierung genutzt werden.

Sie müssen nach der Installation von SQL Server (durch Sie oder die IT-Abteilung) das Annehmen von Remote-Verbindungen in der SQL Server-Instanz konfigurieren. Standardmäßig sind Remote-Verbindungen nicht aktiviert.

Informationen zur Installation und Konfiguration von Microsoft finden Sie in der SQL Server-Dokumentation.

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

Installieren von Clients

Sie können ArcGIS Pro (Desktop Standard oder Desktop Advanced) oder ArcGIS Server (Enterprise Edition) installieren und ein Python-Skript ausführen, um eine Geodatabase zu erstellen. Um das Geoverarbeitungswerkzeug Enterprise-Geodatabase erstellen anstelle eines Skripts auszuführen, installieren Sie ArcGIS Pro.

Hinweis:

Sie benötigen eine ArcGIS ServerSchlüsselcodedatei (Enterprise Edition), um Ihre Geodatabase im nächsten Abschnitt zu autorisieren. Auch wenn Sie zum Erstellen der Geodatabase kein Python-Skript von einem ArcGIS Server-Computer ausführen, installieren und autorisieren Sie ArcGIS Server, um die Schlüsselcodedatei abzurufen. Möglicherweise müssen Sie die Schlüsselcodedatei vom ArcGIS Server-Computer an einen Speicherort kopieren, auf den das Geoverarbeitungswerkzeug Enterprise-Geodatabase erstellen zugreifen kann.

In den meisten Fällen wird der ArcGIS-Client auf einem anderen Computer als SQL Server installiert. Deshalb muss auf dem ArcGIS-Client-Computer ein unterstützter SQL Server Client installiert sein, damit eine Verbindung mit der Datenbank hergestellt werden kann. Lesen Sie die ArcGIS-Systemanforderungen für SQL Server, um festzustellen, welche SQL Server-Clientversion Sie installieren sollten, um die Verbindung zur verwendeten SQL Server-Version herzustellen.

Um eine Verbindung zu SQL Server auf einem Microsoft Windows-Computer herzustellen, können Sie den SQL Server-Client von My Esri oder über das Microsoft Download Center herunterladen. Um eine Verbindung zu SQL Server auf einem Linux-Computer herzustellen, laden Sie die SQL Server-Clientdateien aus dem Microsoft Download Center herunter. Befolgen Sie die Anweisungen von Microsoft für die Installation des SQL Server Client auf Ihrem Client-Computer.

Führen Sie die folgenden Schritte aus, um den Client zu installieren und zu konfigurieren, den Sie zum Erstellen der Geodatabase benötigen. Wenn Sie nicht berechtigt sind, Software zu installieren, müssen Sie diese Schritte von der IT-Abteilung durchführen lassen.

  1. 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.

  2. Installieren Sie einen SQL Server Client auf dem ArcGIS-Client-Computer.

    Wenn Sie den SQL Server Client auf einem 64-Bit-Betriebssystem installieren, verwenden Sie die ausführbare Datei für den 64-Bit SQL Server Client. Wenn Sie SQL Server Client mit 32 Bit auf einem 64-Bit-Betriebssystem ausführen, schlägt die Installation fehl.

Jetzt können Sie eine Geodatabase erstellen.

Erstellen einer Geodatabase

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

Ausführen des Werkzeugs Enterprise-Geodatabase erstellen

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

Führen Sie die folgenden Schritte aus, um eine Geodatabase mithilfe des Werkzeugs Enterprise-Geodatabase erstellen in ArcGIS Pro zu erstellen.

  1. Starten Sie ArcGIS Pro.
  2. Öffnen Sie das Werkzeug Enterprise-Geodatabase erstellen.

    Sie können dieses Werkzeug suchen oder zu diesem Werkzeug navigieren, das sich in der Toolbox "Data Management" im Toolset "Geodatabase-Verwaltung" befindet.

  3. Wählen Sie aus der Dropdown-Liste Datenbankplattform den Eintrag SQL Server aus.
  4. Geben Sie im Textfeld Instanz den Namen der SQL Server-Instanz ein, mit der Sie eine Verbindung herstellen möchten.
  5. Geben Sie im Textfeld Datenbank den Namen der Datenbank ein, in der die Geodatabase gespeichert werden soll.

    Sollte noch keine Datenbank mit diesem Namen in der SQL Server-Instanz vorhanden sein, wird sie erstellt. Ist die Datenbank vorhanden, wird sie zum Speichern der Geodatabase verwendet.

  6. Stellen Sie eine Verbindung mit SQL Server als Systemadministrator her. Verwenden Sie entweder einen Anmeldenamen mit Betriebssystemauthentifizierung, der Mitglied der festgelegten Serverrolle "sysadmin" in SQL Server ist, oder geben Sie Datenbankbenutzernamen und -kennwort für einen sysadmin-Benutzer ein.
    • Um sich über einen sysadmin-Anmeldenamen mit Betriebssystemauthentifizierung authentifizieren 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 zu authentifizieren, geben Sie den Benutzernamen "sysadmin" in das Textfeld Datenbankadministrator und das entsprechende Kennwort in das Textfeld Datenbankadministratorkennwort ein.
  7. Wählen Sie das Schema aus, das die Geodatabase enthält.
    • Wenn Sie einen 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 SDE- oder DBO-Schema finden Sie unter Vergleich von Geodatabase-Besitzern in SQL Server.

  8. Wenn Sie ein SDE-Schema auswählen, enthält das Textfeld Geodatabase-Administrator bereits den Namen "sde". Wenn kein Benutzer mit diesem Namen vorhanden ist, erstellt das Werkzeug diesen Benutzer und das entsprechende Schema und weist dem Benutzer die zum Erstellen einer Geodatabase erforderlichen Berechtigungen zu.

    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.

  9. 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.

  10. Um eine Autorisierungsdatei anzugeben, wechseln Sie zu der Schlüsselcodedatei, die bei der Autorisierung von ArcGIS Server (Enterprise Edition) erstellt wurde, und wählen Sie diese aus.

    Diese Datei wird im Ordner \\Program Files\ESRI\License<release#>\sysgen auf Windows- und im Ordner /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release#>/sysgen auf Linux-Servern erstellt. Kopieren Sie die Schlüsselcodedatei an einen Speicherort, auf den Sie mit dem Werkzeug Enterprise-Geodatabase erstellen zugreifen können. Autorisieren Sie ArcGIS Server jetzt, um diese Datei zu erstellen, sofern Sie dies nicht bereits getan haben.

  11. Klicken Sie auf Ausfü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 Anmeldung "sde" mit Datenbankauthentifizierung, ein Datenbankbenutzer und ein Schema erstellt.

Meldungen im Zusammenhang mit der Geodatabase-Erstellung werden in der Datei sde_setup.log gespeichert, die in dem Verzeichnis erstellt wurde, das für die Variable "%TEMP%" auf dem Computer angegeben wurde, auf dem das Werkzeug ausgeführt wird. Falls Sie Probleme beim Erstellen einer Geodatabase haben, überprüfen Sie diese Datei, 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 angegebene Skript kopieren, speichern und ausführen, um eine Geodatabase aus ArcGIS Pro (Standard oder Advanced) oder ArcGIS Server (Enterprise Edition) zu erstellen.

  1. 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
    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 10.1 and higher releases")
    
    #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 ("--schema", dest="Schema_type", type="choice", choices=['SDE_SCHEMA', 'DBO_SCHEMA'], default="SDE_SCHEMA", help="Schema Type for SQL Server geodatabase, SDE or DBO. Default=SDE_SCHEMA")
    parser.add_option ("-u", dest="Gdb_admin", type="string", default="", help="Geodatabase administrator user name")
    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")
    parser.add_option ("-l", dest="Authorization_file", type="string", default="", help="Full path and name of authorization file")
    parser.add_option ("--type", dest="Spatial_type", type="choice", choices=['ST_GEOMETRY', 'POSTGIS'], default="ST_GEOMETRY", help="Spatial Type for PostgreSQL geodatabase, ST_GEOMETRY or POSTGIS. Default=ST_GEOMETRY")
    
    # 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
    	spatial_type = options.Spatial_type.upper()
    	
    	
    	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( 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.management.CreateEnterpriseGeodatabase(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, spatial_type=spatial_type)
    		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)
  2. Speichern Sie die Datei mit der Erweiterung .py.
  3. 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 von ArcGIS Server 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\License\sysgen\keycodes'

    In diesem Beispiel wird dasselbe Skript für die Erstellung einer Geodatabase im DBO-Schema ausgeführt, wobei eine Anmeldung beim Client-Computer mit einem Anmeldenamen, der Mitglied der festgelegten sysadmin-Serverrolle ist, besteht:

    create_gdb.py --DBMS SQL_SERVER -i porthos\gisprod -D entgdb --auth OPERATING_SYSTEM_AUTH 
    --schema DBO_SCHEMA -l '\\Program Files\ESRI\License\sysgen\keycodes'
    Tipp:

    Type -h or --help at the command prompt to get syntax help.

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

Meldungen im Zusammenhang mit der Geodatabase-Erstellung werden in der Datei sde_setup.log gespeichert, die in dem Verzeichnis erstellt wurde, das für die Variable "%TEMP%" auf dem Computer angegeben wurde, auf dem das Skript ausgeführt wird. Falls Sie Probleme beim Erstellen einer Geodatabase haben, überprüfen Sie diese Datei, um das Problem zu beheben.

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 erstellen 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 Vergleich von Geodatabase-Besitzern 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.

Installieren und Konfigurieren von SQL Server

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

  • Installieren und konfigurieren Sie die SQL Server-Instanz. Die spezifische Konfiguration der Instanz hängt von den Anforderungen Ihrer Organisation ab. Überprüfen Sie die ArcGIS-Systemanforderungen, bevor Sie fortfahren, um sicherzustellen, dass die gewünschten Kombinationen aus Datenbankmanagementsystem, ArcGIS und Hardware unterstützt werden. Stellen Sie nach der Installation von SQL Server sicher, die Akzeptanz von Remote-Verbindungen in der SQL Server-Instanz zu konfigurieren. Standardmäßig sind Remote-Verbindungen nicht aktiviert. Informationen zur Installation und Konfiguration von Microsoft finden Sie in der SQL Server-Dokumentation.

    Hinweis:

    Für die SQL Server-Instanz muss eine Sortierung verwendet werden, bei der nicht zwischen Groß- und Kleinschreibung unterschieden wird. Für die Datenbank darf keine türkische Sortierung genutzt werden.

  • Erstellen Sie eine Datenbank.
  • Stellen Sie die SQL Server-Datenbankoptionen "READ_COMMITTED_SNAPSHOT" und "ALLOW_SNAPSHOT_ISOLATION" auf "ON" ein. Wenn der SQL Server-Administrator diese Optionen nicht auf "ON" einstellt, dem Geodatabase-Administrator jedoch ALTER-Berechtigungen in der Datenbank erteilt, ändert das Werkzeug Enterprise-Geodatabase aktivieren diese Einstellungen in der Datenbank, wenn es ausgeführt wird. Wenn der SQL Server-Administrator diese Optionen nicht festlegt und der Geodatabase-Administrator nicht über ausreichende Berechtigungen verfügt, um diese zu ändern, kann die Geodatabase nicht erstellt werden.
  • 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 Berechtigungen finden Sie unter Berechtigungen für Geodatabases in SQL Server.

Installieren von Clients

Der Geodatabase-Administrator kann ArcGIS Pro (Desktop Standard oder Desktop Advanced) bzw. ArcGIS Server (Enterprise Edition) installieren, um eine Geodatabase durch Ausführung eines Python-Skripts zu erstellen. Installieren Sie ArcGIS Pro, wenn Sie das Geoverarbeitungswerkzeug Enterprise-Geodatabase aktivieren anstelle eines Skripts ausführen möchten.

Hinweis:

Sie benötigen eine ArcGIS ServerSchlüsselcodedatei (Enterprise Edition), um Ihre Geodatabase im nächsten Abschnitt zu autorisieren. Auch wenn Sie zum Erstellen der Geodatabase kein Python-Skript von einem ArcGIS Server-Computer ausführen, müssen Sie ArcGIS Server installieren und autorisieren, um die Schlüsselcodedatei abzurufen. Möglicherweise müssen Sie die Schlüsselcodedatei vom ArcGIS Server-Computer an einen Speicherort kopieren, auf den das Geoverarbeitungswerkzeug Enterprise-Geodatabase aktivieren zugreifen kann.

In den meisten Fällen wird der ArcGIS-Client auf einem anderen Computer als SQL Server installiert. Deshalb muss auf dem ArcGIS-Client-Computer ein unterstützter SQL Server Client installiert sein, damit eine Verbindung mit der Datenbank hergestellt werden kann. Lesen Sie die ArcGIS-Systemanforderungen für SQL Server, um festzustellen, welche SQL Server-Clientversion Sie installieren sollten, um die Verbindung zur verwendeten SQL Server-Version herzustellen.

Um eine Verbindung zu SQL Server auf einem Microsoft Windows-Computer herzustellen, können Sie den SQL Server-Client von My Esri oder über das Microsoft Download Center herunterladen. Um eine Verbindung zu SQL Server auf einem Linux-Computer herzustellen, laden Sie die SQL Server-Clientdateien aus dem Microsoft Download Center herunter. Befolgen Sie die Anweisungen von Microsoft für die Installation des SQL Server Client auf Ihrem Client-Computer.

  1. 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.

  2. Installieren Sie einen SQL Server Client auf dem ArcGIS-Client-Computer.

    Wenn Sie den SQL Server Client auf einem 64-Bit-Betriebssystem installieren, verwenden Sie die ausführbare Datei für den 64-Bit SQL Server Client. Wenn Sie den 32-Bit-SQL Server-Client auf einem 64-Bit-Betriebssystem ausführen, schlägt die Ausführung fehl.

Der ArcGIS-Client ist bereit und kann eine Verbindung zur Datenbank herstellen und eine Geodatabase erstellen. Verwenden Sie hierzu eine der Methoden, die im nächsten Abschnitt beschrieben werden.

Erstellen einer Geodatabase

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

Ausführen des Werkzeugs Enterprise-Geodatabase aktivieren

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

Führen Sie die folgenden Schritte aus, um eine Geodatabase mithilfe des Werkzeugs Enterprise-Geodatabase aktivieren in ArcGIS Pro zu erstellen:

  1. Starten Sie ArcGIS Pro.
  2. Stellen Sie eine Verbindung mit der SQL Server-Datenbank als Geodatabase-Administrator her.

    Speichern Sie das Kennwort des Benutzers im Dialogfeld Datenbankverbindung.

  3. Öffnen Sie dass Werkzeug Enterprise-Geodatabase aktivieren.
  4. Ziehen Sie Ihre neue Datenbankverbindung in das Feld Eingabe-Datenbankverbindung.
  5. Navigieren Sie zu der ArcGIS Server-Autorisierungsdatei, die bei der Autorisierung von ArcGIS Server erstellt wurde, und geben Sie sie im Feld Autorisierungsdatei an.

    Wenn Sie zum Autorisieren von ArcGIS Server den Assistenten verwenden, wird eine Schlüsselcodedatei auf dem Server erzeugt, auf dem die Software installiert ist. Die Schlüsselcodedatei wird im Ordner Program Files\ESRI\License<release>\sysgen auf Windows-Servern und im Verzeichnis /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release#>/sysgen auf Linux-Servern erstellt. Kopieren Sie die Schlüsselcodedatei an einen Speicherort, auf den Sie mit dem Werkzeug Enterprise-Geodatabase aktivieren zugreifen können. Autorisieren Sie ggf. ArcGIS Server, um diese Datei zu erstellen.

  6. Klicken Sie auf Ausführen.

Es wird eine Geodatabase in der Datenbank erstellt.

Meldungen im Zusammenhang mit der Geodatabase-Erstellung werden in der Datei sde_setup.log gespeichert, die in dem Verzeichnis erstellt wurde, das für die Variable "%TEMP%" auf dem Computer angegeben wurde, auf dem das Werkzeug ausgeführt wird. Falls Sie Probleme beim Erstellen einer Geodatabase haben, überprüfen Sie diese Datei, um das Problem zu beheben.

Als Nächstes kann der Datenbankadministrator 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 in ArcGIS Pro (Desktop Standard oder Desktop Advanced) bzw. ArcGIS Server (Enterprise Edition) auf einem Windows-Computer erstellen möchten, können Sie das hier bereitgestellte Skript verwenden.

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

  1. 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
    """
    
    # 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=['SQL_SERVER', 'ORACLE', 'POSTGRESQL', 'DB2','INFORMIX','DB2ZOS', ''], default="", help="Type of enterprise DBMS:  SQL_SERVER, 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)
    
    		
    	# 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 Desktop Standard or Advanced, ArcGIS Engine with the Geodatabase Update extension, or ArcGIS 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)

  2. Speichern Sie die Datei mit der Erweiterung .py.
  3. 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 von ArcGIS Server 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\License\sysgen\keycodes'
    Tipp:

    Type -h or --help at the command prompt to get syntax help.

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

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 kann der Datenbankadministrator einen Benutzer erstellen, der Daten in die Geodatabase laden kann.