Nach oben

Erstellen einer Geodatabase in PostgreSQL unter Windows

In diesem Thema

  1. Voraussetzungen
  2. Sie sind der PostgreSQL- und Geodatabase-Administrator
  3. Der PostgreSQL-Administrator erstellt die Datenbank, der Geodatabase-Administrator erstellt die Geodatabase.

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

Um eine Geodatabase in einer PostgreSQL-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.4 erstellen, lautet die Geodatabase-Version 11.4.0x.

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

Diese Anweisungen gelten für PostgreSQL-Installationen auf einem Microsoft Windows-Server. Wenn PostgreSQL auf einem Linux-Server installiert ist, finden Sie weitere Informationen unter Erstellen einer Geodatabase in PostgreSQL unter Linux.

Voraussetzungen

Um eine Geodatabase in PostgreSQL zu erstellen, gehen Sie wie folgt vor:

  1. Prüfen Sie, ob die gewünschten ArcGIS-, PostgreSQL- und Betriebssystemkombinationen unterstützt werden.
  2. 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.
  3. Wenn Sie die Geodatabase in einer vorhandenen PostgreSQL-Datenbank erstellen oder aktivieren möchten, stellen Sie sicher, dass das öffentliche Schema vorhanden ist.

    Eine der Geodatabase-Systemtabellen wird im öffentlichen Schema erstellt.

  4. Bestimmen Sie, wer die Geodatabase erstellen soll. Dies hat Einfluss darauf, von wem die Datenbank erstellt und welches Werkzeug dabei verwendet wird. Befolgen Sie die Anweisungen, die für Ihre Situation gelten:
    • Wenn Sie der PostgreSQL-Datenbankadministrator und der Geodatabase-Administrator sind, folgen Sie den Anweisungen im nächsten Abschnitt.
    • Handelt es sich bei dem Datenbankadministrator und dem Geodatabase-Administrator nicht um dieselbe Person, folgen Sie zum Erstellen der Datenbank den Anweisungen für den PostgreSQL-Administrator und zum Erstellen der Geodatabase den Anweisungen für den Geodatabase-Administrator.

Sie sind der PostgreSQL- und Geodatabase-Administrator

Wenn Sie sowohl Datenbankadministrator als auch Geodatabase-Administrator sind und das Kennwort für beide Anmelderollen kennen, können Sie mit dem Geoverarbeitungswerkzeug Enterprise-Geodatabase erstellen oder einem Python-Skript, mit dem das Werkzeug aufgerufen wird, eine Geodatabase in PostgreSQL erstellen.

Das Werkzeug Enterprise-Geodatabase erstellen erstellt die für die Geodatabase erforderlichen Datenbankobjekte und gewährt die entsprechenden Berechtigungen. 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:

  • Es wird eine Datenbank mit der PostgreSQL-Standardvorlage (template1) erstellt.

    Wenn Sie die Datenbank mit einer anderen Vorlage erstellen müssen – z. B., wenn Sie die Vorlage "postgis" verwenden möchten –, müssen Sie die Datenbank vor der Ausführung dieses Werkzeugs erstellen. Wenn Sie das Werkzeug Enterprise-Geodatabase erstellen oder ein Skript ausführen, geben Sie den Namen der Datenbank an, die Sie mit einer anderen Vorlage erstellt haben.

  • Es wird eine Anmelderolle mit Datenbankauthentifizierung mit der Bezeichnung "sde" im Datenbank-Cluster erstellt, der Superuser-Status gewährt wird.

    Der Benutzer "sde" muss ein Superuser sein, um die Geodatabase zu erstellen.

  • Es wird ein Schema mit dem Namen "sde" in der Datenbank erstellt.

    Die Systemtabellen, Sichten, Funktionen und Prozeduren der Geodatabase werden im Schema "sde" gespeichert.

  • Der Benutzer "sde" wird als Besitzer des Schemas "sde" festgelegt, und der öffentlichen Rolle werden Verwendungsberechtigungen für das Schema "sde" gewährt.

    Anmelderollen, die die Geodatabase verwenden, müssen auf das Schema "sde" zugreifen können. Da es wahrscheinlich noch keine Geodatabase-Anmelderollen gibt, gewährt dieses Werkzeug der Öffentlichkeit Verwendungsrechte. Nach der Erstellung der Geodatabase können Sie die Sicherheit der Geodatabase erhöhen, indem Sie die Verwendungsrechte für das Schema "sde" durch die Öffentlichkeit widerrufen und nur den Anmeldegruppen und -rollen Verwendungsrechte gewähren, die Zugriff auf die Geodatabase benötigen.

  • Es wird eine Geodatabase erstellt.

Zunächst müssen Sie (oder ein Mitarbeiter Ihrer IT-Abteilung) PostgreSQL installieren und den Datenbank-Cluster konfigurieren.

Installieren und Konfigurieren von PostgreSQL

Befolgen Sie diese Schritte, um einen PostgreSQL-Datenbank-Cluster zum Speichern einer Geodatabase einzurichten:

  1. Laden Sie eine unterstützte Version von PostgreSQL herunter, und installieren Sie diese. Konfigurieren Sie den Datenbank-Cluster.

    Anweisungen zum Installieren und Konfigurieren von PostgreSQL finden Sie in der PostgreSQL-Dokumentation.

  2. Konfigurieren Sie den Datenbank-Cluster, so dass dieser Verbindungen akzeptiert.

    Hierzu müssen Sie u. a. die Datei pg_hba.conf so ändern, dass der Datenbank-Cluster Remote-Verbindungen zulässt.

  3. Erstellen Sie im Datenbank-Cluster einen Tablespace, in dem die Datenbank gespeichert werden kann. Wenn Sie keinen Tablespace erstellen, wird der Tablespace "pg_default" verwendet.

Installieren und konfigurieren Sie als Nächstes einen ArcGIS-Client.

Installieren eines ArcGIS-Clients

ArcGIS Pro (Desktop Standard oder Desktop Advanced) oder ArcGIS Server muss von Ihnen (oder einem Mitarbeiter Ihrer IT-Abteilung) installiert werden. Von jedem dieser Clients können Sie 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 Schlüsselcodedatei für ArcGIS Server (Enterprise Edition), um die 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 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 erstellen zugreifen kann.

Gewähren von Zugriff auf einen räumlichen Datentyp

Um eine Geodatabase zu speichern, benötigt PostgreSQL Zugriff auf einen räumlichen Datentyp. Sie können Zugriff auf den räumlichen Datentyp "ST_Geometry" von Esri für den Datenbank-Cluster gewähren oder PostGIS installieren.

Wenn der Datenbank-Cluster Zugriff auf einen räumlichen Datentyp hat, können Sie eine Geodatabase erstellen.

ST_Geometry

Um "ST_Geometry" in der Geodatabase zu verwenden, speichern Sie die Datei st_geometry.dll im PostgreSQL-Verzeichnis lib.

Sie können die Datei st_geometry.dll von My Esri herunterladen.

Hinweis:

Für st_geometry.dll wird das Microsoft Visual C++ Redistributable Package (x64) benötigt. Informationen zur erforderlichen Paketversion finden Sie unter PostgreSQL-Datenbankanforderungen. Wenn dieses Paket auf dem PostgreSQL-Server nicht verfügbar ist, laden Sie es von der Microsoft-Site herunter, und installieren Sie es.

Speichern Sie die Datei st_geometry.dll, die Ihrer PostgreSQL-Version entspricht, im PostgreSQL-Verzeichnis lib. Stellen Sie sicher, dass Sie die richtige Dateiversion verwenden.

PostGIS

Um räumliche PostGIS-Datentypen in der Geodatabase zu verwenden, müssen Sie PostGIS auf dem PostgreSQL-Datenbank-Cluster installieren. Stellen Sie sicher, dass Sie die von ArcGIS unterstützte PostGIS-Version installieren.

Erstellen einer Geodatabase

Um eine Geodatabase zu erstellen, führen Sie das Werkzeug Enterprise-Geodatabase erstellen aus ArcGIS Pro aus, oder führen Sie ein Python-Skript aus, das dieses Werkzeug von einem ArcGIS Pro- oder ArcGIS Server-Computer aus aufruft.

Ausführen des Werkzeugs Enterprise-Geodatabase 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 PostgreSQL aus.
  4. Geben Sie im Textfeld Instanz den Namen des PostgreSQL-Servers ein.
  5. Geben Sie im Textfeld Datenbank den Namen der Datenbank ein, in der die Geodatabase gespeichert werden soll.
    Hinweis:

    Geben Sie den Datenbanknamen in Kleinbuchstaben ein, da Objektnamen mit Großbuchstaben oder Groß- und Kleinbuchstaben für Geodatabases in PostgreSQL nicht unterstützt werden. Wenn Sie einen Datenbanknamen in Großschreibung oder in kombinierter Groß-/Kleinschreibung eingeben, wird er von ArcGIS in Kleinschreibung konvertiert.

  6. Sie müssen die Verbindung zur Datenbank als Postgres-Superuser herstellen, um die Datenbank und andere Objekte erstellen zu können. Im Textfeld Datenbankadministrator wird daher standardmäßig postgres angezeigt.

    Wenn der Superuser einen anderen Namen hat, geben Sie diesen Namen in das Textfeld Datenbankadministrator ein.

    Bei dieser Version können Sie keine Postgres-Superuser-Anmeldung mit Betriebssystemauthentifizierung verwenden.

  7. Geben Sie das Kennwort für den Postgres-Superuser in das Textfeld Datenbankadministrator-Kennwort ein.
    8. Der Geodatabase-Administrator muss in PostgreSQL als "sde" bezeichnet werden. Deshalb ist das Textfeld Geodatabase-Administrator standardmäßig bereits mit sde ausgefüllt.
  8. Geben Sie ein Kennwort für den Benutzer "sde" in das Textfeld Geodatabase-Administratorkennwort ein.

    Wenn im Datenbank-Cluster bereits ein SDE-Benutzer vorhanden ist, geben Sie das Kennwort des vorhandenen Benutzers ein. Dann wird in der Datenbank ein SDE-Schema erstellt. Wenn der Benutzer noch nicht vorhanden ist, wird ein Benutzer mit dem Namen "sde" und dem von Ihnen angegebenen Kennwort im Datenbank-Cluster erstellt, und in der Datenbank wird ein entsprechendes Schema erstellt. Der öffentlichen Gruppenrolle wird Zugriff auf das SDE-Schema gewährt.

    Tipp:

    Um die Sicherheit des Schemas nach dem Erstellen der Geodatabase zu erhöhen, können Sie der Gruppenrolle "public" die Verwendungsberechtigung entziehen. Erstellen Sie anschließend eine neue Gruppenrolle, gewähren Sie dieser Rolle Zugriff auf das SDE-Schema, und weisen Sie allen Anmelderollen, die auf die Geodatabase zugreifen müssen, diese Gruppenrolle zu.

  9. Wenn Sie einen Tablespace konfigurieren, den Sie als standardmäßigen Tablespace für die Datenbank verwenden möchten, geben Sie seinen Namen in das Textfeld Tablespace-Name ein.

    Mit diesem Werkzeug wird kein Tablespace erstellt. Sie müssen entweder einen vorhandenen Tablespace angeben oder das Textfeld leer lassen. Wenn Sie keinen Tablespace angeben, wird die Datenbank in "pg_default" erstellt.

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

    Diese Datei wird in das Verzeichnis \\Program Files\ESRI\License<release#>\sysgen geschrieben, wenn Sie ArcGIS Server unter Windows installieren, und in das Verzeichnis /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release#>/sysgen, wenn Sie ArcGIS Server unter Linux installieren. Kopieren Sie diese Datei an einen Speicherort, auf den der Client, über den Sie die Geodatabase erstellen, zugreifen kann. Autorisieren Sie ArcGIS Server jetzt, um diese Datei zu erstellen, sofern Sie dies nicht bereits getan haben.

  11. Verwenden Sie die Dropdown-Liste Räumlicher Datentyp, um den Datentyp auszuwählen, den die Geodatabase verwenden soll: "ST_Geometry" oder PostGIS.
  12. Klicken Sie auf Ausführen.

Sie verfügen nun über eine Geodatabase in einer PostgreSQL-Datenbank.

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, finden Sie weitere Informationen zum Beheben des Problems in dieser Datei.

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

Ausführen eines Python-Skripts von einem ArcGIS-Client-Computer

Sie können das hier angegebene Skript kopieren, speichern und ausführen, um eine Geodatabase über einen ArcGIS Pro (Desktop Standard oder Desktop Advanced) oder ArcGIS Server-Computer 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.

    In der folgenden Beispielausführung über einen Windows-Computer wird die Datei create_gdb.py für einen Datenbank-Cluster mit dem Namen "pgprod" als Superuser "postgres" mit dem Kennwort "N0pe3king!" ausgeführt. Dabei werden eine Datenbank mit dem Namen "entgdb" in einem vorhandenen Tablespace mit dem Namen "gis" und die Anmelderolle "sde" mit dem Kennwort "Tgdbst@rtsh3r3" erstellt. Im Standardverzeichnis von ArcGIS Server wird eine Schlüsselcodedatei angegeben, um die Geodatabase zu autorisieren.

    create_gdb.py --DBMS POSTGRESQL -i pgprod -D entgdb --auth DATABASE_AUTH 
-U postgres -P N0pe3king! -u sde -p Tgdbst@rtsh3r3 -t gis -l '\\Program Files\ESRI\License\sysgen\keycodes'

    In diesem Beispiel wird dasselbe Skript auf einem Linux-Computer ausgeführt:

    ./create_gdb.py --DBMS POSTGRESQL -i pgprod -D entgdb --auth DATABASE_AUTH 
-U postgres -P N0pe3king! -u sde -p Tgdbst@rtsh3r3 -t gis -l '/usr/arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License/sysgen/keycodes'

    Tipp:

    Geben Sie in der Eingabeaufforderung -h oder --help ein, um die Syntaxhilfe aufzurufen.

Sie verfügen nun über eine Geodatabase in einer PostgreSQL-Datenbank.

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" oder "TMP" auf dem Computer angegeben wurde, auf dem das Skript ausgeführt wird. Falls Sie Probleme beim Erstellen einer Geodatabase haben, finden Sie weitere Informationen zum Beheben des Problems in dieser Datei.

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

Der PostgreSQL-Administrator erstellt die Datenbank, der Geodatabase-Administrator erstellt die Geodatabase.

Besitzt der Benutzer, der die Geodatabase erstellt, keinen Zugriff auf das Kennwort des Datenbankadministrators (des Postgres-Superusers), muss der Datenbankadministrator die Datenbank, die SDE-Anmelderolle und das SDE-Schema erstellen. Als Nächstes kann der Geodatabase-Administrator über die SDE-Anmeldung eine Verbindung mit der Datenbank herstellen und mit dem Geoverarbeitungswerkzeug Enterprise Geodatabase aktivieren oder einem Python-Skript, das dieses Werkzeug aufruft, eine Geodatabase erstellen.

Das Werkzeug Enterprise-Geodatabase aktivieren verwendet eine Datenbankverbindungsdatei als Eingabe und erstellt die Geodatabase-Systemtabellen, -sichten, -funktionen und -prozeduren im Schema "sde". Bevor das Werkzeug ausgeführt werden kann, muss der Datenbankadministrator Folgendes im PostgreSQL-Datenbank-Cluster einrichten:

  • eine Anmelderolle mit dem Namen "sde" mit Superuser-Status
  • eine Datenbank
  • ein SDE-Schema in der Datenbank, für das die SDE-Anmeldung Berechtigungen besitzt
  • einen räumlichen Typ: Die Bibliothek "st_geometry" muss im Ordner lib im PostgreSQL-Installationsverzeichnis vorhanden sein, oder PostGIS muss in der Datenbank konfiguriert sein.

Installieren und Konfigurieren von PostgreSQL und eines räumlichen Datentyps

Zunächst muss der Datenbankadministrator PostgreSQL zum Speichern einer Geodatabase vorbereiten.

Um den PostgreSQL-Datenbank-Cluster als Datenbankadministrator einzurichten, führen Sie die folgenden Schritte aus:

Hinweis:

Alle Datenbankobjektnamen dürfen nur Kleinbuchstaben enthalten.

  1. Laden Sie eine unterstützte Version von PostgreSQL herunter, und installieren Sie diese. Konfigurieren Sie den Datenbank-Cluster.

    Anweisungen zum Installieren und Konfigurieren von PostgreSQL finden Sie in der PostgreSQL-Dokumentation.

  2. Konfigurieren Sie den Datenbank-Cluster, so dass dieser Verbindungen akzeptiert.

    Hierzu müssen Sie u. a. die Datei pg_hba.conf so ändern, dass der Datenbank-Cluster Remote-Verbindungen zulässt.

  3. Erstellen Sie optional im Datenbank-Cluster einen Tablespace, in dem die Datenbank gespeichert werden kann.
  4. Erstellen Sie eine Anmelderolle mit dem Namen "sde" mit Superuser-Status.

    Tipp:

    Wenn der Geodatabase-Administrator keine Datenbankverbindungen entfernt, können Sie den Administratorstatus von der Rolle "sde" widerrufen, nachdem die Datenbank erstellt wurde.

  5. Erstellen Sie die Datenbank, die zum Speichern der Geodatabase verwendet werden soll.
  6. Erstellen Sie in der Datenbank ein Schema mit dem Namen "sde", und autorisieren Sie die Anmelderolle für dieses Schema.
  7. Aktivieren Sie einen räumlichen Datentyp in der Datenbank.
    • Eine Anleitung zur Konfiguration von PostGIS in der Datenbank finden Sie in der PostGIS-Dokumentation. Fahren Sie anschließend mit Schritt 9 fort.
    • Fahren Sie zur Konfiguration von "ST_Geometry" mit dem nächsten Schritt fort.
  8. Rufen Sie die Bibliothek "ST_Geometry" ab, und speichern Sie sie im PostgreSQL-Verzeichnis lib.
    1. Laden Sie die Datei st_geometry.dll von My Esri herunter.

      Laden Sie die richtige Bibliothek für die verwendete PostgreSQL-Version herunter. Wenn Sie die falsche Version verwenden, kann die Geodatabase nicht erstellt werden.

      Wenden Sie sich an den Administrator Ihrer ArcGIS-Organisation, wenn die Download-Option nicht vorhanden ist.

      Hinweis:

      Für die Datei st_geometry.dll wird das Microsoft Visual C++ Redistributable Package (x64) benötigt. Informationen zur erforderlichen Paketversion finden Sie unter PostgreSQL-Datenbankanforderungen. Wenn dieses Paket auf dem PostgreSQL-Server nicht verfügbar ist, laden Sie es von der Microsoft-Site herunter, und installieren Sie es.

    2. Speichern Sie die Datei st_geometry.dll im PostgreSQL-Verzeichnis lib auf dem Computer, auf dem PostgreSQL installiert wurde.
  9. Händigen Sie dem Geodatabase-Administrator die Datenbankverbindungsinformationen aus.

    Der Geodatabase-Administrator muss den Datenbank-Cluster-Namen, den Datenbanknamen und das Kennwort für die Anmelderolle "sde" kennen.

Nachdem eine Datenbank erstellt wurde, kann der Geodatabase-Administrator einen ArcGIS-Client installieren und eine Geodatabase erstellen.

Installieren eines ArcGIS-Clients

Der Geodatabase-Administrator benötigt einen ArcGIS-Client, über den die Geodatabase erstellt wird: ArcGIS Pro (Desktop Standard oder Desktop Advanced) oder ArcGIS Server.

Hinweis:

Sie benötigen eine Schlüsselcodedatei für ArcGIS Server (Enterprise Edition), um die 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.

Nachdem der ArcGIS-Client installiert wurde, können Sie eine Verbindung zur Datenbank herstellen und eine Geodatabase erstellen.

Erstellen einer Geodatabase

Um eine Geodatabase in der vorhandenen Datenbank zu erstellen, kann der Geodatabase-Administrator entweder das Werkzeug Enterprise-Geodatabase aktivieren aus ArcGIS Pro (Desktop Standard oder Desktop Advanced) oder ein Python-Skript aus ArcGIS Pro oder ArcGIS Server ausführen, das dieses Werkzeug aufruft.

Ausführen des Werkzeugs Enterprise-Geodatabase aktivieren

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 PostgreSQL-Datenbank als SDE-Benutzer her.

    Wenn es sich beim SDE-Benutzer um einen Benutzer mit Datenbankauthentifizierung handelt, müssen Sie das Kennwort des SDE-Benutzers in der Datenbankverbindung speichern.

  3. Öffnen Sie dass Werkzeug Enterprise-Geodatabase aktivieren.
  4. Ziehen Sie die neue Verbindungsdatei in das Feld Eingabedatenbank.
  5. Um einem Wert für die 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 in das Verzeichnis \\Program Files\ESRI\License<release#>\sysgen geschrieben, wenn Sie ArcGIS Server unter Windows installieren, und in das Verzeichnis /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release#>/sysgen, wenn Sie ArcGIS Server unter Linux installieren. Kopieren Sie diese Datei an einen Speicherort, auf den der Client, über den Sie die Geodatabase erstellen, zugreifen kann. Autorisieren Sie ArcGIS Server jetzt, um diese Datei zu erstellen, sofern Sie dies nicht bereits getan haben.

  6. Klicken Sie auf Ausführen.

Sie verfügen nun über eine Geodatabase in einer PostgreSQL-Datenbank.

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, finden Sie weitere Informationen zum Beheben des Problems in dieser Datei.

Als Nächstes kann der Datenbankadministrator Anmelderollen und entsprechende Schemas für Benutzer erstellen, die die Daten erstellen, bearbeiten und anzeigen sollen, und Anmelderollen für Editoren und Benutzer, die Daten anzeigen, erstellen.

Ausführen eines Python-Skripts von einem ArcGIS-Client-Computer

Zum Erstellen der Geodatabase durch Ausführen eines Skriptes auf einem Computer mit ArcGIS Pro (Desktop Standard oder Desktop Advanced) oder ArcGIS Server können Sie das hier verfügbare Skript verwenden.

Führen Sie die folgenden Schritte aus, um ein Python-Skript zum Erstellen einer Geodatabase in einer PostgreSQL-Datenbank auszuführen:

  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 auf einem Windows-Computer ausgeführt. Der Name der Datenbank lautet "spdata", und sie befindet sich in einem Datenbank-Cluster namens "pgprod". Die Verbindung wird als SDE-Anmeldung mit dem Kennwort "Tgdbst@rtsh3r3" hergestellt. Im Standardverzeichnis von ArcGIS Server auf Windows wird eine Schlüsselcodedatei angegeben, um die Geodatabase zu autorisieren.

    enable_gdb.py --DBMS POSTGRESQL -i pgprod --auth DATABASE_AUTH 
-u sde -p Tgdbst@rtsh3r3 -D spdata -l '\\Program Files\ESRI\License\sysgen\keycodes'

    In diesem Beispiel wird dieselbe Datei auf einem Linux-Computer ausgeführt, und die Schlüsselcodedatei befindet sich im ArcGIS Server-Standardverzeichnis unter Linux.

    ./enable_gdb.py --DBMS POSTGRESQL -i pgprod --auth DATABASE_AUTH 
-u sde -p Tgdbst@rtsh3r3 -D spdata -l '/usr/arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License/sysgen/keycodes'

    Tipp:

    Geben Sie in der Eingabeaufforderung -h oder --help ein, um die Syntaxhilfe aufzurufen.

Sie verfügen nun über eine Geodatabase in einer PostgreSQL-Datenbank.

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" oder "TMP" auf dem Computer angegeben wurde, auf dem das Skript ausgeführt wird. Falls Sie Probleme beim Erstellen einer Geodatabase haben, finden Sie weitere Informationen zum Beheben des Problems in dieser Datei.

Als Nächstes kann der Datenbankadministrator Anmelderollen und entsprechende Schemas für Benutzer erstellen, die die Daten erstellen, bearbeiten und anzeigen sollen, und Anmelderollen für Editoren und Benutzer, die Daten anzeigen, erstellen.

Feedback zu diesem Thema?

In diesem Thema
  1. Voraussetzungen
  2. Sie sind der PostgreSQL- und Geodatabase-Administrator
  3. Der PostgreSQL-Administrator erstellt die Datenbank, der Geodatabase-Administrator erstellt die Geodatabase.